Struct mr_bundle::Bundle

pub struct Bundle<M>
where
    M: Manifest,
{ /* private fields */ }

A Manifest bundled together, optionally, with the Resources that it describes. This is meant to be serialized for standalone distribution, and deserialized by the receiver.

The manifest may describe locations of resources not included in the Bundle.

Implementations

impl<M> Bundle<M>

where M: Manifest,

pub fn new<R: IntoIterator<Item = (PathBuf, ResourceBytes)>>( manifest: M, resources: R, root_dir: PathBuf ) -> MrBundleResult<Self>

Creates a bundle containing a manifest and a collection of resources to be bundled together with the manifest.

The paths paired with each resource must correspond to the set of Location::Bundles specified in the Manifest::location(), or else this is not a valid bundle.

A base directory must also be supplied so that relative paths can be resolved into absolute ones.

pub fn new_unchecked<R: IntoIterator<Item = (PathBuf, ResourceBytes)>>( manifest: M, resources: R ) -> MrBundleResult<Self>

Create a bundle, asserting that all paths in the Manifest are absolute.

pub fn manifest(&self) -> &M

Accessor for the Manifest

pub fn update_manifest(self, manifest: M) -> MrBundleResult<Self>

Return a new Bundle with an updated manifest, subject to the same validation constraints as creating a new Bundle from scratch.

pub async fn read_from_file(path: &Path) -> MrBundleResult<Self>

Load a Bundle into memory from a file

pub async fn write_to_file(&self, path: &Path) -> MrBundleResult<()>

Write a Bundle to a file

pub async fn resolve( &self, location: &Location ) -> MrBundleResult<Cow<'_, ResourceBytes>>

Retrieve the bytes for a resource at a Location, downloading it if necessary

pub async fn resolve_all( &self ) -> MrBundleResult<HashMap<Location, Cow<'_, ResourceBytes>>>

Return the full set of resources specified by this bundle’s manifest. References to bundled resources can be returned directly, while all others will be fetched from the filesystem or the network.

pub async fn resolve_all_cloned( &self ) -> MrBundleResult<HashMap<Location, ResourceBytes>>

Resolve all resources, but with fully owned references

pub fn bundled_resources(&self) -> &BTreeMap<PathBuf, ResourceBytes>

Access the map of resources included in this bundle Bundled resources are also accessible via resolve or resolve_all, but using this method prevents a Clone

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

An arbitrary and opaque encoding of the bundle data into a byte array

pub fn decode(bytes: &[u8]) -> MrBundleResult<Self>

Decode bytes produced by encode

Trait Implementations

impl<M> Debug for Bundle<M>

where M: Manifest + Debug,

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

Formats the value using the given formatter.

impl<'de, M> Deserialize<'de> for Bundle<M>

where M: Manifest + DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M> PartialEq for Bundle<M>

where M: Manifest + PartialEq,

fn eq(&self, other: &Bundle<M>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<M> Serialize for Bundle<M>

where M: Manifest + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<M> Eq for Bundle<M>

where M: Manifest + Eq,

impl<M> StructuralPartialEq for Bundle<M>

where M: Manifest,