mirror of
https://github.com/privatevoid-net/nix-super.git
synced 2024-09-21 08:58:04 +03: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>
51 lines
1.5 KiB
C++
51 lines
1.5 KiB
C++
#pragma once
|
|
///@file
|
|
|
|
/**
|
|
* Declare comparison methods without defining them.
|
|
*/
|
|
#define DECLARE_ONE_CMP(COMPARATOR, MY_TYPE) \
|
|
bool operator COMPARATOR(const MY_TYPE & other) const;
|
|
#define DECLARE_EQUAL(my_type) \
|
|
DECLARE_ONE_CMP(==, my_type)
|
|
#define DECLARE_LEQ(my_type) \
|
|
DECLARE_ONE_CMP(<, my_type)
|
|
#define DECLARE_NEQ(my_type) \
|
|
DECLARE_ONE_CMP(!=, my_type)
|
|
#define DECLARE_CMP(my_type) \
|
|
DECLARE_EQUAL(my_type) \
|
|
DECLARE_LEQ(my_type) \
|
|
DECLARE_NEQ(my_type)
|
|
|
|
/**
|
|
* Awful hacky generation of the comparison operators by doing a lexicographic
|
|
* 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_ONE_CMP(COMPARATOR, MY_TYPE, ...) \
|
|
bool 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(args...) GENERATE_ONE_CMP(==, args)
|
|
#define GENERATE_LEQ(args...) GENERATE_ONE_CMP(<, args)
|
|
#define GENERATE_NEQ(args...) GENERATE_ONE_CMP(!=, args)
|
|
#define GENERATE_CMP(args...) \
|
|
GENERATE_EQUAL(args) \
|
|
GENERATE_LEQ(args) \
|
|
GENERATE_NEQ(args)
|