#include "sync.hh"

    {
        auto state_(state.lock());
        auto res = state_->narInfoCache.get(storePath);
        if (res) {
            stats.narInfoReadAverted++;
            return **res;
        }
    }

    auto narInfo = NarInfo(getFile(narInfoFile), narInfoFile);
    assert(narInfo.path == storePath);

    auto narInfo = make_ref<NarInfo>(getFile(narInfoFile), narInfoFile);
    assert(narInfo->path == storePath);

        if (!narInfo.checkSignature(*publicKeys))

        if (!narInfo->checkSignature(*publicKeys))

    return narInfo;

    {
        auto state_(state.lock());
        state_->narInfoCache.upsert(storePath, narInfo);
        stats.narInfoCacheSize = state_->narInfoCache.size();
    }
    return *narInfo;

#include "lru-cache.hh"
#include "sync.hh"

    struct State
    {
        LRUCache<Path, ref<NarInfo>> narInfoCache{32 * 1024};
    };
    Sync<State> state;

        std::atomic<uint64_t> narInfoReadAverted{0};

        std::atomic<uint64_t> narInfoCacheSize{0};

            nested.attr("narInfoReadAverted", stats.narInfoReadAverted);

            nested.attr("narInfoCacheSize", stats.narInfoCacheSize);

#pragma once
#include <map>
#include <list>
/* A simple least-recently used cache. Not thread-safe. */
template<typename Key, typename Value>
class LRUCache
{
private:
    size_t maxSize;
    // Stupid wrapper to get around circular dependency between Data
    // and LRU.
    struct LRUIterator;
    using Data = std::map<Key, std::pair<LRUIterator, Value>>;
    using LRU = std::list<typename Data::iterator>;
    struct LRUIterator { typename LRU::iterator it; };
    Data data;
    LRU lru;
public:
    LRUCache(size_t maxSize) : maxSize(maxSize) { }
    /* Insert or upsert an item in the cache. */
    void upsert(const Key & key, const Value & value)
    {
        erase(key);
        if (data.size() >= maxSize) {
            /* Retire the oldest item. */
            auto oldest = lru.begin();
            data.erase(*oldest);
            lru.erase(oldest);
        }
        auto res = data.emplace(key, std::make_pair(LRUIterator(), value));
        assert(res.second);
        auto & i(res.first);
        auto j = lru.insert(lru.end(), i);
        i->second.first.it = j;
    }
    bool erase(const Key & key)
    {
        auto i = data.find(key);
        if (i == data.end()) return false;
        lru.erase(i->second.first.it);
        data.erase(i);
        return true;
    }
    /* Look up an item in the cache. If it's exists, it becomes the
       most recently used item. */
    // FIXME: use boost::optional?
    Value * get(const Key & key)
    {
        auto i = data.find(key);
        if (i == data.end()) return 0;
        /* Move this item to the back of the LRU list. */
        lru.erase(i->second.first.it);
        auto j = lru.insert(lru.end(), i);
        i->second.first.it = j;
        return &i->second.second;
    }
    size_t size()
    {
        return data.size();
    }
};

template <class T>

template<class T>