attr-set.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libexpr/nixexpr.hh"
#include "lix/libexpr/symbol-table.hh"
 
#include <algorithm>
 
namespace nix {
 
 
class EvalMemory;
struct Value;

struct Attr
{
    /* the placement of `name` and `pos` in this struct is important.
       both of them are uint32 wrappers, they are next to each other
       to make sure that Attr has no padding on 64 bit machines. that
       way we keep Attr size at two words with no wasted space. */
    Symbol name;
    PosIdx pos;
    Value * value;
    Attr(Symbol name, Value * value, PosIdx pos = noPos)
        : name(name), pos(pos), value(value) { };
    Attr() { };
    bool operator < (const Attr & a) const
    {
        return name < a.name;
    }
};
 
static_assert(sizeof(Attr) == 2 * sizeof(uint32_t) + sizeof(Value *),
    "performance of the evaluator is highly sensitive to the size of Attr. "
    "avoid introducing any padding into Attr if at all possible, and do not "
    "introduce new fields that need not be present for almost every instance.");

class Bindings
{
public:
    using Size = uint32_t;
    PosIdx pos;
 
    static Bindings EMPTY;
 
private:
    Size size_, capacity_;
    Attr attrs[0];
 
    Bindings(Size capacity) : size_(0), capacity_(capacity) { }
    Bindings(const Bindings & bindings) = delete;
 
public:
    Size size() const { return size_; }
 
    bool empty() const { return !size_; }
 
    typedef Attr * iterator;
 
    void push_back(const Attr & attr)
    {
        assert(size_ < capacity_);
        attrs[size_++] = attr;
    }
 
    iterator find(Symbol name)
    {
        Attr key(name, 0);
        iterator i = std::lower_bound(begin(), end(), key);
        if (i != end() && i->name == name) return i;
        return end();
    }
 
    Attr * get(Symbol name)
    {
        Attr key(name, 0);
        iterator i = std::lower_bound(begin(), end(), key);
        if (i != end() && i->name == name) return &*i;
        return nullptr;
    }
 
    iterator begin() { return &attrs[0]; }
    iterator end() { return &attrs[size_]; }
 
    Attr & operator[](Size pos)
    {
        return attrs[pos];
    }
 
    void sort();
 
    Size capacity() { return capacity_; }

    std::vector<const Attr *> lexicographicOrder(const SymbolTable & symbols) const
    {
        std::vector<const Attr *> res;
        res.reserve(size_);
        for (Size n = 0; n < size_; n++)
            res.emplace_back(&attrs[n]);
        std::sort(res.begin(), res.end(), [&](const Attr * a, const Attr * b) {
            std::string_view sa = symbols[a->name], sb = symbols[b->name];
            return sa < sb;
        });
        return res;
    }
 
    friend class EvalMemory;
};

class BindingsBuilder
{
    Bindings * bindings;
    EvalMemory & mem;
    SymbolTable & symbols;
 
public:
    // needed by std::back_inserter
    using value_type = Attr;
 
    BindingsBuilder(EvalMemory & mem, SymbolTable & symbols, Bindings * bindings)
        : bindings(bindings)
        , mem(mem)
        , symbols(symbols)
    { }
 
    void insert(Symbol name, Value * value, PosIdx pos = noPos)
    {
        insert(Attr(name, value, pos));
    }
 
    void insert(const Attr & attr)
    {
        push_back(attr);
    }
 
    void push_back(const Attr & attr)
    {
        bindings->push_back(attr);
    }
 
    Value & alloc(Symbol name, PosIdx pos = noPos);
 
    Value & alloc(std::string_view name, PosIdx pos = noPos);
 
    Bindings * finish()
    {
        bindings->sort();
        return bindings;
    }
 
    Bindings * alreadySorted()
    {
        return bindings;
    }
};
 
}