Struct StorePath

pub struct StorePath { /* private fields */ }

Represents a store path which is something that is produced by nix-build.

A store path represents an output in the nix store, matching the pattern store_dir/hash-name (most often, store_dir will be /nix/store).

Using nix, a store path can be produced by calling nix-build.

Note that even if a store path is a directory, the files inside that directory themselves are not store paths. For example, while the following is a store path:

/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5

while this is not:

/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5/bin/

To avoid any confusion with file paths, we sometimes also refer to a store path as a package.

Implementations

impl StorePath

pub fn parse(origin: PathOrigin, path: &str) -> Option<StorePath>

Parse a store path from an absolute file path.

Since this function does not know where that path comes from, it takes origin as an argument.

This function returns None if the path could not be parsed as a store path. You should not rely on that to check whether a path is a store path though, since it only does minimal validation (for one example, it does not check the length of the hash).

pub fn encode(&self) -> Result<Vec<u8>>

Encodes a store path as a sequence of bytes, so that it can be decoded with decode.

The encoding does not use the bytes 0x00 nor 0x01, as long as none of the fields of this path contain those bytes (this includes store_dir, hash, name and origin). This is important since it allows the result to be encoded with frcode.

Panics

The attr and output of the path origin must not contain the byte value 0x02, otherwise this function panics.

pub fn decode(buf: &[u8]) -> Option<StorePath>

pub fn name(&self) -> Cow<'_, str>

Returns the name of the store path, which is the part of the file name that is not the hash. In the above example, it would be bash-4.4-p5.

Example

use nix_index::package::{PathOrigin, StorePath};

let origin = PathOrigin { attr: "dummy".to_string(), output: "out".to_string(), toplevel: true, system: None };
let store_path = StorePath::parse(origin, "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5").unwrap();
assert_eq!(&store_path.name(), "bash-4.4-p5");

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

The hash of the store path. This is the part just before the name of the path.

Example

use nix_index::package::{PathOrigin, StorePath};

let origin = PathOrigin { attr: "dummy".to_string(), output: "out".to_string(), toplevel: true, system: None };
let store_path = StorePath::parse(origin, "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5").unwrap();
assert_eq!(&store_path.name(), "bash-4.4-p5");

pub fn store_dir(&self) -> Cow<'_, str>

The store dir for which this store path was built.

Currently, this will be /nix/store in almost all cases, but we include it here anyway for completeness.

Example

use nix_index::package::{PathOrigin, StorePath};

let origin = PathOrigin { attr: "dummy".to_string(), output: "out".to_string(), toplevel: true, system: None };
let store_path = StorePath::parse(origin, "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5").unwrap();
assert_eq!(&store_path.store_dir(), "/nix/store");

pub fn as_str(&self) -> Cow<'_, str>

Converts the store path back into an absolute path.

Example

use nix_index::package::{PathOrigin, StorePath};

let origin = PathOrigin { attr: "dummy".to_string(), output: "out".to_string(), toplevel: true, system: None };
let store_path = StorePath::parse(origin, "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5").unwrap();
assert_eq!(&store_path.as_str(), "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5");

pub fn origin(&self) -> Cow<'_, PathOrigin>

Returns the origin that describes how we discovered this store path.

See the documentation of PathOrigin for more information about this field.

Example

use nix_index::package::{PathOrigin, StorePath};

let origin = PathOrigin { attr: "dummy".to_string(), output: "out".to_string(), toplevel: true, system: None };
let store_path = StorePath::parse(origin.clone(), "/nix/store/010yd8jls8w4vcnql4zhjbnyp2yay5pl-bash-4.4-p5").unwrap();
assert_eq!(store_path.origin().as_ref(), &origin);

Trait Implementations

impl Clone for StorePath

fn clone(&self) -> StorePath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StorePath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StorePath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for StorePath

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for StorePath

fn cmp(&self, other: &StorePath) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for StorePath

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

fn partial_cmp(&self, other: &StorePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for StorePath

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 StorePath

impl StructuralPartialEq for StorePath