mirror of
https://github.com/NixOS/nix
synced 2025-06-25 10:41:16 +02:00
60b7121d2c
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
98 lines
2.3 KiB
C++
98 lines
2.3 KiB
C++
#pragma once
|
||
///@file
|
||
|
||
#include "util.hh"
|
||
#include "comparator.hh"
|
||
#include "derived-path.hh"
|
||
|
||
#include <variant>
|
||
|
||
#include <nlohmann/json_fwd.hpp>
|
||
|
||
namespace nix {
|
||
|
||
class BadNixStringContextElem : public Error
|
||
{
|
||
public:
|
||
std::string_view raw;
|
||
|
||
template<typename... Args>
|
||
BadNixStringContextElem(std::string_view raw_, const Args & ... args)
|
||
: Error("")
|
||
{
|
||
raw = raw_;
|
||
auto hf = hintfmt(args...);
|
||
err.msg = hintfmt("Bad String Context element: %1%: %2%", normaltxt(hf.str()), raw);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Plain opaque path to some store object.
|
||
*
|
||
* Encoded as just the path: ‘<path>’.
|
||
*/
|
||
typedef SingleDerivedPath::Opaque NixStringContextElem_Opaque;
|
||
|
||
/**
|
||
* Path to a derivation and its entire build closure.
|
||
*
|
||
* The path doesn't just refer to derivation itself and its closure, but
|
||
* also all outputs of all derivations in that closure (including the
|
||
* root derivation).
|
||
*
|
||
* Encoded in the form ‘=<drvPath>’.
|
||
*/
|
||
struct NixStringContextElem_DrvDeep {
|
||
StorePath drvPath;
|
||
|
||
GENERATE_CMP(NixStringContextElem_DrvDeep, me->drvPath);
|
||
};
|
||
|
||
/**
|
||
* Derivation output.
|
||
*
|
||
* Encoded in the form ‘!<output>!<drvPath>’.
|
||
*/
|
||
typedef SingleDerivedPath::Built NixStringContextElem_Built;
|
||
|
||
using _NixStringContextElem_Raw = std::variant<
|
||
NixStringContextElem_Opaque,
|
||
NixStringContextElem_DrvDeep,
|
||
NixStringContextElem_Built
|
||
>;
|
||
|
||
struct NixStringContextElem : _NixStringContextElem_Raw {
|
||
using Raw = _NixStringContextElem_Raw;
|
||
using Raw::Raw;
|
||
|
||
using Opaque = NixStringContextElem_Opaque;
|
||
using DrvDeep = NixStringContextElem_DrvDeep;
|
||
using Built = NixStringContextElem_Built;
|
||
|
||
inline const Raw & raw() const & {
|
||
return static_cast<const Raw &>(*this);
|
||
}
|
||
inline Raw & raw() & {
|
||
return static_cast<Raw &>(*this);
|
||
}
|
||
inline Raw && raw() && {
|
||
return static_cast<Raw &&>(*this);
|
||
}
|
||
|
||
/**
|
||
* Decode a context string, one of:
|
||
* - ‘<path>’
|
||
* - ‘=<path>’
|
||
* - ‘!<name>!<path>’
|
||
*
|
||
* @param xpSettings Stop-gap to avoid globals during unit tests.
|
||
*/
|
||
static NixStringContextElem parse(
|
||
std::string_view s,
|
||
const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
|
||
std::string to_string() const;
|
||
};
|
||
|
||
typedef std::set<NixStringContextElem> NixStringContext;
|
||
|
||
}
|