Struct Outputs 

pub struct Outputs(OutputsInner);

Derivation outputs with filled out StorePath.

Each output has an OutputName and a StorePath and Outputs provides a map of OutputName to StorePath to provide easy access while still maintaining invariants.

In general there are two types of outputs: fixed or input addressed. And while the fixed output also has a name and a StorePath it addtionally also has a OutputHash.

Invariants

• Only a single FOD output is allowed and it must be named out
• Duplicately named outputs is an error
• Outputs can not be empty

Tuple Fields

0: OutputsInner

Implementations

impl Outputs

pub fn fixed_output(output_hash: OutputHash, store_path: StorePath) -> Self

Create Outputs with a fixed output with provided output_hash and store_path.

This single fixed output is always named out.

pub fn input_addressed_from_iter<I>(it: I) -> Result<Self, OutputsError>

where I: IntoIterator<Item = (OutputName, StorePath)>,

Try to create input addressed Outputs from the provided iterator.

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

pub fn try_from_iter<I>(it: I) -> Result<Self, OutputsError>

where I: IntoIterator<Item = (OutputName, StorePath, Option<OutputHash>)>,

Try to make Outputs from the provided iterator.

This will return a OutputsError if the OutputName, StorePath, OutputHash tuple in the iterator don’t follow the invariants.

pub fn as_fixed_output_hash(&self) -> Option<&OutputHash>

Return output hash if this Outputs is fixed.

pub fn as_fixed_output(&self) -> Option<(&OutputHash, &StorePath)>

Return output hash and store path if this Outputs is fixed.

pub fn into_builder(self) -> OutputsBuilder

Convert this Outputs into an OutputsBuilder with the same type and output names.

pub fn into_unverified_builder(self) -> UnverifiedOutputsBuilder

Convert this Outputs into an OutputsBuilder with the same type and output names.

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

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

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

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

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

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

pub fn names(&self) -> OutputNames<'_>

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

Examples

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

let out_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyia-has-multi-out".parse().unwrap();
let bin_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyib-has-multi-out-bin".parse().unwrap();
let a = Outputs::input_addressed_from_iter([
    (OutputName::out(), out_sp),
    (OutputName::from_static("bin").unwrap(), bin_sp),
]).expect("multiple outputs");

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

pub fn into_names(self) -> IntoOutputNames

Convert this Outputs to an iterator over the names of the outputs, in sorted order.

pub fn store_paths(&self) -> impl Iterator<Item = &StorePath>

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

Examples

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

let out_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyia-has-multi-out".parse().unwrap();
let a = Outputs::input_addressed_from_iter([(OutputName::out(), out_sp.clone())]).unwrap();

let values: Vec<StorePath> = a.store_paths().cloned().collect();
assert_eq!(values, [out_sp]);

pub fn len(&self) -> usize

Returns the number of outputs

Examples

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

let out_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyia-has-multi-out".parse().unwrap();
let a = Outputs::input_addressed_from_iter([(OutputName::out(), out_sp.clone())]).unwrap();
assert_eq!(a.len(), 1);

let bin_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyib-has-multi-out-bin".parse().unwrap();
let b = Outputs::input_addressed_from_iter([
    (OutputName::out(), out_sp),
    (OutputName::from_static("bin").unwrap(), bin_sp),
]).expect("multiple outputs");
assert_eq!(b.len(), 2);

pub fn is_single(&self) -> bool

Returns true if this contains only a single output.

Examples

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

let out_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyia-has-multi-out".parse().unwrap();

let a = Outputs::fixed_output(output_hash, out_sp.clone());
assert!(a.is_single());

let b = Outputs::input_addressed_from_iter([(OutputName::out(), out_sp.clone())]).unwrap();
assert!(b.is_single());

let bin_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyib-has-multi-out-bin".parse().unwrap();
let c = Outputs::input_addressed_from_iter([
    (OutputName::out(), out_sp),
    (OutputName::from_static("bin").unwrap(), bin_sp),
]).unwrap();
assert!(!c.is_single());

pub fn is_fixed(&self) -> bool

Returns true if this is a single fixed-output.

Examples

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

let out_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyia-has-multi-out".parse().unwrap();
let a = Outputs::fixed_output(output_hash, out_sp.clone());
assert!(a.is_fixed());

let b = Outputs::input_addressed_from_iter([(OutputName::out(), out_sp.clone())]).unwrap();
assert!(!b.is_fixed());

let bin_sp : StorePath = "2vixb94v0hy2xc6p7mbnxxcyc095yyib-has-multi-out-bin".parse().unwrap();
let c = Outputs::input_addressed_from_iter([
    (OutputName::out(), out_sp),
    (OutputName::from_static("bin").unwrap(), bin_sp),
]).unwrap();
assert!(!c.is_fixed());

pub fn is_input_addressed(&self) -> bool

Returns true if this is a set of input addressed outputs.

Trait Implementations

impl AtermWriteable for Outputs

fn aterm_write(&self, writer: &mut impl Write) -> Result<()>

impl Clone for Outputs

fn clone(&self) -> Outputs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Outputs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Outputs

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Outputs> for OutputsBuilder

fn from(value: Outputs) -> Self

Converts to this type from the input type.

impl From<Outputs> for UnverifiedOutputsBuilder

fn from(value: Outputs) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a Outputs

type Item = (&'a OutputName, &'a StorePath)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Outputs

type Item = (OutputName, StorePath)

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl NixDeserialize for Outputs

Available on crate features wire and nix-compat-derive only.

async fn try_deserialize<R>(reader: &mut R) -> Result<Option<Self>, R::Error>

where R: ?Sized + NixRead + Send,

Read a value from the reader. This returns an Option to support gracefull shutdown.

fn deserialize<R>( reader: &mut R, ) -> impl Future<Output = Result<Self, R::Error>> + Send + '_

where R: ?Sized + NixRead + Send,

impl NixSerialize for Outputs

Available on crate features wire and nix-compat-derive only.

async fn serialize<W>(&self, writer: &mut W) -> Result<(), W::Error>

where W: NixWrite,

Write a value to the writer.

impl PartialEq<Outputs> for OutputsBuilder

fn eq(&self, other: &Outputs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<OutputsBuilder> for Outputs

fn eq(&self, other: &OutputsBuilder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Outputs

fn eq(&self, other: &Outputs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Outputs

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Outputs

impl StructuralPartialEq for Outputs