2021-02-04 16:11:05 +02:00
|
|
|
#pragma once
|
2023-04-01 06:18:41 +03:00
|
|
|
///@file
|
2021-02-04 16:11:05 +02:00
|
|
|
|
Allow dynamic derivation deps in `inputDrvs`
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>
2021-10-02 01:05:53 +03:00
|
|
|
#define DECLARE_ONE_CMP(PRE, QUAL, COMPARATOR, MY_TYPE) \
|
|
|
|
PRE bool QUAL operator COMPARATOR(const MY_TYPE & other) const;
|
|
|
|
#define DECLARE_EQUAL(prefix, qualification, my_type) \
|
|
|
|
DECLARE_ONE_CMP(prefix, qualification, ==, my_type)
|
|
|
|
#define DECLARE_LEQ(prefix, qualification, my_type) \
|
|
|
|
DECLARE_ONE_CMP(prefix, qualification, <, my_type)
|
|
|
|
#define DECLARE_NEQ(prefix, qualification, my_type) \
|
|
|
|
DECLARE_ONE_CMP(prefix, qualification, !=, my_type)
|
|
|
|
|
|
|
|
#define GENERATE_ONE_CMP(PRE, QUAL, COMPARATOR, MY_TYPE, ...) \
|
|
|
|
PRE bool QUAL operator COMPARATOR(const MY_TYPE & other) const { \
|
|
|
|
__VA_OPT__(const MY_TYPE * me = this;) \
|
|
|
|
auto fields1 = std::make_tuple( __VA_ARGS__ ); \
|
|
|
|
__VA_OPT__(me = &other;) \
|
|
|
|
auto fields2 = std::make_tuple( __VA_ARGS__ ); \
|
|
|
|
return fields1 COMPARATOR fields2; \
|
|
|
|
}
|
|
|
|
#define GENERATE_EQUAL(prefix, qualification, my_type, args...) \
|
|
|
|
GENERATE_ONE_CMP(prefix, qualification, ==, my_type, args)
|
|
|
|
#define GENERATE_LEQ(prefix, qualification, my_type, args...) \
|
|
|
|
GENERATE_ONE_CMP(prefix, qualification, <, my_type, args)
|
|
|
|
#define GENERATE_NEQ(prefix, qualification, my_type, args...) \
|
|
|
|
GENERATE_ONE_CMP(prefix, qualification, !=, my_type, args)
|
|
|
|
|
Make the Derived Path family of types inductive for dynamic derivations
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>
2023-01-16 00:39:04 +02:00
|
|
|
/**
|
|
|
|
* Declare comparison methods without defining them.
|
|
|
|
*/
|
|
|
|
#define DECLARE_CMP(my_type) \
|
Allow dynamic derivation deps in `inputDrvs`
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>
2021-10-02 01:05:53 +03:00
|
|
|
DECLARE_EQUAL(,,my_type) \
|
|
|
|
DECLARE_LEQ(,,my_type) \
|
|
|
|
DECLARE_NEQ(,,my_type)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param prefix This is for something before each declaration like
|
|
|
|
* `template<classname Foo>`.
|
|
|
|
*
|
|
|
|
* @param my_type the type are defining operators for.
|
|
|
|
*/
|
|
|
|
#define DECLARE_CMP_EXT(prefix, qualification, my_type) \
|
|
|
|
DECLARE_EQUAL(prefix, qualification, my_type) \
|
|
|
|
DECLARE_LEQ(prefix, qualification, my_type) \
|
|
|
|
DECLARE_NEQ(prefix, qualification, my_type)
|
Make the Derived Path family of types inductive for dynamic derivations
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>
2023-01-16 00:39:04 +02:00
|
|
|
|
2023-03-27 04:12:25 +03:00
|
|
|
/**
|
|
|
|
* Awful hacky generation of the comparison operators by doing a lexicographic
|
2021-02-04 16:11:05 +02:00
|
|
|
* comparison between the choosen fields.
|
|
|
|
*
|
|
|
|
* ```
|
|
|
|
* GENERATE_CMP(ClassName, me->field1, me->field2, ...)
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* will generate comparison operators semantically equivalent to:
|
|
|
|
*
|
|
|
|
* ```
|
|
|
|
* bool operator<(const ClassName& other) {
|
|
|
|
* return field1 < other.field1 && field2 < other.field2 && ...;
|
|
|
|
* }
|
|
|
|
* ```
|
|
|
|
*/
|
|
|
|
#define GENERATE_CMP(args...) \
|
Allow dynamic derivation deps in `inputDrvs`
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>
2021-10-02 01:05:53 +03:00
|
|
|
GENERATE_EQUAL(,,args) \
|
|
|
|
GENERATE_LEQ(,,args) \
|
|
|
|
GENERATE_NEQ(,,args)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param prefix This is for something before each declaration like
|
|
|
|
* `template<classname Foo>`.
|
|
|
|
*
|
|
|
|
* @param my_type the type are defining operators for.
|
|
|
|
*/
|
|
|
|
#define GENERATE_CMP_EXT(prefix, my_type, args...) \
|
|
|
|
GENERATE_EQUAL(prefix, my_type ::, my_type, args) \
|
|
|
|
GENERATE_LEQ(prefix, my_type ::, my_type, args) \
|
|
|
|
GENERATE_NEQ(prefix, my_type ::, my_type, args)
|