Struct Arx 

pub struct Arx {
    pub container: Container,
    pub root_index: Index,
    pub properties: AllProperties,
}

Fields

container: Container

root_index: Index

properties: AllProperties

Implementations

impl Arx

pub fn new<P: AsRef<Path>>(file: P) -> Result<Self, ArxError>

pub fn create_properties( &self, index: &Index, ) -> Result<AllProperties, ArxError>

pub fn get_entry<B>(&self, path: &Path) -> Result<Entry<B::Entry>, QueryError>

where B: FullBuilderTrait,

pub fn get_entry_in_range<B, R>( &self, path: &Path, range: &R, ) -> Result<Entry<B::Entry>, QueryError>

where B: FullBuilderTrait, R: Range,

pub fn get_entry_at_idx<B>( &self, idx: EntryIdx, ) -> Result<Option<Entry<B::Entry>>, ArxError>

where B: FullBuilderTrait,

Methods from Deref<Target = Container>

pub fn pack_count(&self) -> PackCount

The number of packs in the container.

pub fn get_pack( &self, pack_id: PackId, ) -> Result<Option<MayMissPack<&ContentPack>>, Error>

Get a pack for the given pack_id.

If pack_id is not found in the manifest, return None. As a existing pack may be actually missing, we return a MayMissPack which is kind of option, but with a pack_info payload in the “None”

pub fn get_bytes( &self, content: ContentAddress, ) -> Result<Option<MayMissPack<Option<ByteRegion>>>, Error>

Get bytes associated to a content address.

This imply 2 lookups:

• One to get the pack
• One to get the bytes from the pack.

So the return value of this method is a bit complex. Classic use case, when content address come from the jubako archive itself is:

let bytes = container
            .get_bytes(content_address)?
            .and_then(|m| m.transpose())
            .expect("As content address should be valid, we should have a bytes (or a MayMissPack)");
            // `expect(...)` may be replaced with `or_or(SomeFormatError::new(...))?`
match bytes {
    MayMissPack::FOUND(bytes) => { read_from_bytes(bytes) }
    MayMissPack::MISSING(pack_info) => { display_user_pack_is_missing(pack_info) }
}

pub fn get_directory_pack(&self) -> &Arc<DirectoryPack>

Get the directory pack of the container

pub fn get_value_storage(&self) -> &Arc<ValueStorage>

Get the value storage of the container

pub fn get_entry_storage(&self) -> &Arc<EntryStorage>

Get the entry storage of the container

pub fn get_index_for_name(&self, name: &str) -> Result<Option<Index>, Error>

Get a index by its name

pub fn check(&self) -> Result<bool, Error>

Check the container

pub fn uuid(&self) -> Uuid

Get the uuid of the container (manifest_pack)

Trait Implementations

impl Deref for Arx

type Target = Container

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.