Struct Outputs

Source

pub struct Outputs(OutputsInner);

Expand description

Derivation outputs.

Outputs are generally mappings from OutputName to a Output but with some extra invariants.

§Invariants

If there is only one output it is named out
Only a single FOD output is allowed
Duplicately named outputs is an error
Outputs can not be empty

§`StorePath` for an `Output`

When a derivation is being constructed the StorePath of each output is not known yet and so Outputs does support this.

But generally you should call calculate_output_paths and after that the StorePath of each output is available and will never change.

It is for this reason that the only method mutating Outputs after construction is calculate_output_paths.

Tuple Fields§

§0: OutputsInner

Implementations§

Source §

impl Outputs

Source

pub const fn from_fod_hash(output_hash: OutputHash) -> Self

Return Ouputs with single fixed-output that matches output_hash.

§Examples

use nix_compat::derivation::{Outputs, OutputName};

let b = Outputs::from_fod_hash(output_hash);
assert!(b.is_single());
assert!(b.is_fixed());
assert!(b.contains_key(&OutputName::out()));

Source

pub const fn with_single_output() -> Self

Return a new Ouputs with just a single output.

That single output is always called out.

§Examples

use nix_compat::derivation::{Outputs, OutputName};

let b = Outputs::with_single_output();
assert!(b.is_single());
assert!(b.contains_key(&OutputName::out()));

Source

pub fn try_from_iter(it: I) -> Result<Self, OutputsError>
where I: IntoIterator<Item = (OutputName, Output)>,

Try to make Outputs from the provided iterator.

This will return a OutputsError if the OutputName, Output pairs in the iterator don’t follow the invariants.

Source

pub fn contains_key(&self, name: &OutputName) -> bool

Returns true if the outputs contains an output with the specified name.

Source

pub fn get(&self, name: &OutputName) -> Option<&Output>

Returns a reference to the Output corresponding to the provided name.

Source

pub fn iter(&self) -> Iter<'_> ⓘ

Gets an iterator over the entries of the outputs, sorted by name.

Source

pub fn keys(&self) -> impl Iterator<Item = &OutputName>

Gets an iterator over the names of the outputs, in sorted order.

§Examples

use nix_compat::derivation::{Outputs, OutputName};

let a = Outputs::try_from_iter([
    (OutputName::out(), Default::default()),
    (OutputName::from_static("bin").unwrap(), Default::default()),
]).expect("multiple outputs");

let keys: Vec<OutputName> = a.keys().cloned().collect();
assert_eq!(keys, [
    OutputName::from_static("bin").unwrap(),
    OutputName::out(),
]);

Source

pub fn values(&self) -> impl Iterator<Item = &Output>

Gets an iterator over the Output values of the outputs, in order by name.

§Examples

use nix_compat::derivation::{Output, Outputs, OutputName};

let a = Outputs::with_single_output();

let values: Vec<Output> = a.values().cloned().collect();
assert_eq!(values, [Output::default()]);

Source

pub fn len(&self) -> usize

Returns the number of outputs

§Examples

use nix_compat::derivation::{Outputs, OutputName};

let a = Outputs::with_single_output();
assert_eq!(a.len(), 1);

let b = Outputs::try_from_iter([
    (OutputName::out(), Default::default()),
    (OutputName::from_static("bin").unwrap(), Default::default()),
]).expect("multiple outputs");
assert_eq!(b.len(), 2);

Source

pub fn is_single(&self) -> bool

Returns true if this contains only a single output.

§Examples

use nix_compat::derivation::{Outputs, OutputName};

let a = Outputs::with_single_output();
assert!(a.is_single());

let b = Outputs::from_fod_hash(output_hash);
assert!(b.is_single());

let c = Outputs::try_from_iter([
    (OutputName::out(), Default::default()),
    (OutputName::from_static("bin").unwrap(), Default::default()),
]).unwrap();
assert!(!c.is_single());

Source

pub fn is_fixed(&self) -> bool

Returns true if this is a single fixed-output.

Source

pub fn calculate_output_paths( &mut self, drv_name: &str, hash_derivation_modulo: &[u8; 32], ) -> Result<(), OutputsError>

This calculates all output paths of a Outputs and updates the struct.

It requires the struct to be initially without output paths. This means, Output::path needs to be None for each output.

Output path calculation requires knowledge of the hash_derivation_modulo, which (in case of non-fixed-output derivations) also requires knowledge of the hash_derivation_modulo of input derivations (recursively).

To avoid recursing and doing unnecessary calculation, we simply ask the caller of this function to provide the result of the hash_derivation_modulo call of the current Derivation, and leave it up to them to calculate it when needed.

On completion, Output::path of each output is set to the calculated output path.