7ad66cb3ef
We use the same nested map representation we used for goals, again in order to save space. We might someday want to combine with `inputDrvs`, by doing `V = bool` instead of `V = std::set<OutputName>`, but we are not doing that yet for sake of a smaller diff. The ATerm format for Derivations also needs to be extended, in addition to the in-memory format. To accomodate this, we added a new basic versioning scheme, so old versions of Nix will get nice errors. (And going forward, if the ATerm format changes again the errors will be even better.) `parsedStrings`, an internal function used as part of parsing derivations in A-Term format, used to consume the final `]` but expect the initial `[` to already be consumed. This made for what looked like unbalanced brackets at callsites, which was confusing. Now it consumes both which is hopefully less confusing. As part of testing, we also created a unit test for the A-Term format for regular non-experimental derivations too. Co-authored-by: Robert Hensing <roberth@users.noreply.github.com> Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io> Apply suggestions from code review Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
99 lines
2.7 KiB
C++
99 lines
2.7 KiB
C++
#pragma once
|
|
|
|
#include "types.hh"
|
|
#include "derived-path.hh"
|
|
|
|
namespace nix {
|
|
|
|
/**
|
|
* A simple Trie, of sorts. Conceptually a map of `SingleDerivedPath` to
|
|
* values.
|
|
*
|
|
* Concretely, an n-ary tree, as described below. A
|
|
* `SingleDerivedPath::Opaque` maps to the value of an immediate child
|
|
* of the root node. A `SingleDerivedPath::Built` maps to a deeper child
|
|
* node: the `SingleDerivedPath::Built::drvPath` is first mapped to a a
|
|
* child node (inductively), and then the
|
|
* `SingleDerivedPath::Built::output` is used to look up that child's
|
|
* child via its map. In this manner, every `SingleDerivedPath` is
|
|
* mapped to a child node.
|
|
*
|
|
* @param V A type to instantiate for each output. It should probably
|
|
* should be an "optional" type so not every interior node has to have a
|
|
* value. For example, the scheduler uses
|
|
* `DerivedPathMap<std::weak_ptr<CreateDerivationAndRealiseGoal>>` to
|
|
* remember which goals correspond to which outputs. `* const Something`
|
|
* or `std::optional<Something>` would also be good choices for
|
|
* "optional" types.
|
|
*/
|
|
template<typename V>
|
|
struct DerivedPathMap {
|
|
/**
|
|
* A child node (non-root node).
|
|
*/
|
|
struct ChildNode {
|
|
/**
|
|
* Value of this child node.
|
|
*
|
|
* @see DerivedPathMap for what `V` should be.
|
|
*/
|
|
V value;
|
|
|
|
/**
|
|
* The map type for the root node.
|
|
*/
|
|
using Map = std::map<OutputName, ChildNode>;
|
|
|
|
/**
|
|
* The map of the root node.
|
|
*/
|
|
Map childMap;
|
|
|
|
DECLARE_CMP(ChildNode);
|
|
};
|
|
|
|
/**
|
|
* The map type for the root node.
|
|
*/
|
|
using Map = std::map<StorePath, ChildNode>;
|
|
|
|
/**
|
|
* The map of root node.
|
|
*/
|
|
Map map;
|
|
|
|
DECLARE_CMP(DerivedPathMap);
|
|
|
|
/**
|
|
* Find the node for `k`, creating it if needed.
|
|
*
|
|
* The node is referred to as a "slot" on the assumption that `V` is
|
|
* some sort of optional type, so the given key can be set or unset
|
|
* by changing this node.
|
|
*/
|
|
ChildNode & ensureSlot(const SingleDerivedPath & k);
|
|
|
|
/**
|
|
* Like `ensureSlot` but does not create the slot if it doesn't exist.
|
|
*
|
|
* Read the entire description of `ensureSlot` to understand an
|
|
* important caveat here that "have slot" does *not* imply "key is
|
|
* set in map". To ensure a key is set one would need to get the
|
|
* child node (with `findSlot` or `ensureSlot`) *and* check the
|
|
* `ChildNode::value`.
|
|
*/
|
|
ChildNode * findSlot(const SingleDerivedPath & k);
|
|
};
|
|
|
|
|
|
DECLARE_CMP_EXT(
|
|
template<>,
|
|
DerivedPathMap<std::set<std::string>>::,
|
|
DerivedPathMap<std::set<std::string>>);
|
|
DECLARE_CMP_EXT(
|
|
template<>,
|
|
DerivedPathMap<std::set<std::string>>::ChildNode::,
|
|
DerivedPathMap<std::set<std::string>>::ChildNode);
|
|
|
|
}
|