Struct MetaContents 

pub struct MetaContents { /* private fields */ }

A MetaContents represents the “meta/contents” file of a Fuchsia archive file of a Fuchsia package. It validates that all resource paths are valid and that none of them start with “meta/”.

Implementations

impl MetaContents

pub const PATH: &'static str = "meta/contents"

pub fn from_map(map: PackedMap<str, Hash>) -> Result<Self, MetaContentsError>

Creates a MetaContents from a map from resource paths to Merkle roots. Validates that:

1. all resource paths are valid Fuchsia package resource paths,
2. none of the resource paths start with “meta/”,
3. none of the resource paths are “meta”,
4. none of the resource paths have directories that collide with other full resource paths, e.g. path combination [“foo”, “foo/bar”] would be rejected because it has both a file and a directory at path “foo”.

Examples

let map = PackedMap::from([
    ("bin/my_prog".to_string(),
        Hash::from_str(
            "0000000000000000000000000000000000000000000000000000000000000000")
        .unwrap()),
    ("lib/mylib.so".to_string(),
        Hash::from_str(
            "1111111111111111111111111111111111111111111111111111111111111111")
        .unwrap()),
]);
let meta_contents = MetaContents::from_map(map).unwrap();

pub fn new() -> Self

Creates an empty MetaContents.

pub fn get(&self, path: &str) -> Option<&Hash>

Returns the Merkle root for the given resource path, if present.

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

Returns an iterator over the package paths.

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

Returns an iterator over the package hashes.

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

Returns an iterator over the entries of the map, sorted by key.

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

Serializes a “meta/contents” file to writer.

Examples

let map = PackedMap::from([
    ("bin/my_prog".to_string(),
        Hash::from_str(
            "0000000000000000000000000000000000000000000000000000000000000000")
        .unwrap()),
    ("lib/mylib.so".to_string(),
        Hash::from_str(
            "1111111111111111111111111111111111111111111111111111111111111111")
        .unwrap()),
]);
let meta_contents = MetaContents::from_map(map).unwrap();
let mut bytes = Vec::new();
meta_contents.serialize(&mut bytes).unwrap();
let expected = "bin/my_prog=0000000000000000000000000000000000000000000000000000000000000000\n\
                lib/mylib.so=1111111111111111111111111111111111111111111111111111111111111111\n";
assert_eq!(bytes.as_slice(), expected.as_bytes());

pub fn deserialize(reader: impl BufRead) -> Result<Self, MetaContentsError>

Deserializes a “meta/contents” file from a reader.

Examples

let bytes = "bin/my_prog=0000000000000000000000000000000000000000000000000000000000000000\n\
             lib/mylib.so=1111111111111111111111111111111111111111111111111111111111111111\n".as_bytes();
let meta_contents = MetaContents::deserialize(bytes).unwrap();
let expected_contents = PackedMap::from([
    ("bin/my_prog".to_string(),
        Hash::from_str(
            "0000000000000000000000000000000000000000000000000000000000000000")
        .unwrap()),
    ("lib/mylib.so".to_string(),
        Hash::from_str(
            "1111111111111111111111111111111111111111111111111111111111111111")
        .unwrap()),
]);
assert_eq!(meta_contents.contents(), &expected_contents);

pub fn contents(&self) -> &PackedMap<str, Hash>

Get the map from blob resource paths to Merkle Tree root hashes.

pub fn into_contents(self) -> PackedMap<str, Hash>

Take the map from blob resource paths to Merkle Tree root hashes.

pub fn into_hashes_undeduplicated(self) -> impl Iterator<Item = Hash>

Take the Merkle Tree root hashes in a iterator. The returned iterator may include duplicates.

Trait Implementations

impl Clone for MetaContents

fn clone(&self) -> MetaContents

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaContents

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

Formats the value using the given formatter.

impl Default for MetaContents

fn default() -> Self

Returns the “default value” for a type.

impl Eq for MetaContents

impl<T, const N: usize> From<[(T, GenericDigest<FuchsiaMerkleMarker>); N]> for MetaContents

where T: AsRef<str>,

fn from(items: [(T, Hash); N]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<(T, GenericDigest<FuchsiaMerkleMarker>)> for MetaContents

where T: AsRef<str>,

fn from_iter<I: IntoIterator<Item = (T, Hash)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a MetaContents

type Item = (&'a str, &'a GenericDigest<FuchsiaMerkleMarker>)

The type of the elements being iterated over.

type IntoIter = Iter<'a, str, GenericDigest<FuchsiaMerkleMarker>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for MetaContents

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