eval-cache.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/sync.hh"
#include "lix/libutil/hash.hh"
#include "lix/libexpr/eval.hh"
 
#include <functional>
#include <variant>
 
namespace nix::eval_cache {
 
struct AttrDb;
class AttrCursor;
 
typedef std::function<Value *(EvalState &)> RootLoader;
 
class CachingEvaluator : public Evaluator
{
    std::map<Hash, ref<EvalCache>> caches;
 
public:
    using Evaluator::Evaluator;
 
    ref<EvalCache> getCacheFor(Hash hash, RootLoader rootLoader);
};
 
class EvalCache : public std::enable_shared_from_this<EvalCache>
{
    friend class AttrCursor;
 
    std::shared_ptr<AttrDb> db;
    RootLoader rootLoader;
    RootValue value;
 
    Value * getRootValue(EvalState & state);
 
public:
 
    EvalCache(
        std::optional<std::reference_wrapper<const Hash>> useCache,
        RootLoader rootLoader);
 
    ref<AttrCursor> getRoot();
};
 
enum AttrType {
    Placeholder = 0,
    FullAttrs = 1,
    String = 2,
    Missing = 3,
    Misc = 4,
    Failed = 5,
    Bool = 6,
    ListOfStrings = 7,
    Int = 8,
};
 
struct placeholder_t {};
struct fullattr_t { std::vector<std::string> p; };
struct missing_t {};
struct misc_t {};
struct failed_t {};
struct int_t { NixInt x; };
typedef uint64_t AttrId;
typedef std::pair<AttrId, std::string> AttrKey;
typedef std::pair<std::string, NixStringContext> string_t;
 
typedef std::variant<
    fullattr_t,
    string_t,
    placeholder_t,
    missing_t,
    misc_t,
    failed_t,
    bool,
    int_t,
    std::vector<std::string>
    > AttrValue;
 
class AttrCursor : public std::enable_shared_from_this<AttrCursor>
{
    friend class EvalCache;
 
    ref<EvalCache> root;
    typedef std::optional<std::pair<std::shared_ptr<AttrCursor>, std::string>> Parent;
    Parent parent;
    RootValue _value;
    std::optional<std::pair<AttrId, AttrValue>> cachedValue;
 
    AttrKey getKey();
 
    Value & getValue(EvalState & state);
 
public:
 
    AttrCursor(
        ref<EvalCache> root,
        Parent parent,
        Value * value = nullptr,
        std::optional<std::pair<AttrId, AttrValue>> && cachedValue = {});
 
    std::vector<std::string> getAttrPath(EvalState & state) const;
 
    std::vector<std::string> getAttrPath(EvalState & state, std::string_view name) const;
 
    std::string getAttrPathStr(EvalState & state) const;
 
    std::string getAttrPathStr(EvalState & state, std::string_view name) const;
 
    Suggestions getSuggestionsForAttr(EvalState & state, const std::string & name);
 
    std::shared_ptr<AttrCursor> maybeGetAttr(EvalState & state, const std::string & name);
 
    ref<AttrCursor> getAttr(EvalState & state, const std::string & name);
 
    OrSuggestions<ref<AttrCursor>> findAlongAttrPath(EvalState & state, const std::vector<std::string> & attrPath);
 
    std::string getString(EvalState & state);
 
    string_t getStringWithContext(EvalState & state);
 
    bool getBool(EvalState & state);
 
    NixInt getInt(EvalState & state);
 
    std::vector<std::string> getListOfStrings(EvalState & state);
 
    std::vector<std::string> getAttrs(EvalState & state);
 
    bool isDerivation(EvalState & state);
 
    Value & forceValue(EvalState & state);
 
    StorePath forceDerivation(EvalState & state);
};
 
}