Enum nix_compat::nixhash::CAHash

pub enum CAHash {
    Flat(NixHash),
    Nar(NixHash),
    Text([u8; 32]),
}

A Nix CAHash describes a content-addressed hash of a path.

The way Nix prints it as a string is a bit confusing, but there’s essentially three modes, Flat, Nar and Text. Flat and Nar support all 4 algos that NixHash supports (sha1, md5, sha256, sha512), Text only supports sha256.

Variants

Flat(NixHash)

Nar(NixHash)

Text([u8; 32])

Implementations

impl CAHash

pub fn hash(&self) -> Cow<'_, NixHash>

pub fn mode(&self) -> HashMode

pub fn algo_str(&self) -> &'static str

Returns a colon-separated string consisting of mode, recursiveness and hash algo. Used as a prefix in various string representations.

pub fn from_nix_hex_str(s: &str) -> Option<Self>

Constructs a CAHash from the textual representation, which is one of the three:

• text:sha256:$nixbase32sha256digest
• fixed:r:$algo:$nixbase32digest
• fixed:$algo:$nixbase32digest

These formats are used in NARInfo, for example.

pub fn to_nix_nixbase32_string(&self) -> String

Formats a CAHash in the Nix default hash format, which is the format that’s used in NARInfos for example.

pub(crate) fn from_map<'de, D>( map: &Map<String, Value>, ) -> Result<Option<Self>, D::Error>

where D: Deserializer<'de>,

This takes a serde_json::Map and turns it into this structure. This is necessary to do such shenigans because we have external consumers, like the Derivation parser, who would like to know whether we have a invalid or a missing NixHashWithMode structure in another structure, e.g. Output. This means we have this combinatorial situation:

• no hash, no hashAlgo: no CAHash so we return Ok(None).
• present hash, missing hashAlgo: invalid, we will return missing_field
• missing hash, present hashAlgo: same
• present hash, present hashAlgo: either we return ourselves or a type/value validation error.

This function is for internal consumption regarding those needs until we have a better solution. Now this is said, let’s explain how this works.

We want to map the serde data model into a CAHash.

The serde data model has a hash field (containing a digest in nixbase32), and a hashAlgo field, containing the stringified hash algo. In case the hash is recursive, hashAlgo also has a r: prefix.

This is to match how nix show-derivation command shows them in JSON representation.

Trait Implementations

impl Clone for CAHash

fn clone(&self) -> CAHash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CAHash

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CAHash

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl NixDeserialize for CAHash

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 CAHash

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

where W: NixWrite,

Write a value to the writer.

impl PartialEq for CAHash

fn eq(&self, other: &CAHash) -> 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 CAHash

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

where S: Serializer,

map a CAHash into the serde data model.

impl Eq for CAHash

impl StructuralPartialEq for CAHash