Struct asuran::manifest::Manifest

pub struct Manifest<T: Backend> { /* fields omitted */ }

Repository manifest

This is the root object of the repository, all objects that are active can be reached through the Mainfest.

Implementations

impl<T: BackendClone> Manifest<T>

pub fn load(repo: &Repository<T>) -> Manifest<T> where
    T: Backend, 

Loads the manifest from the repository

Panics

Will panic if loading the manifest fails

pub async fn set_chunk_settings(
    &mut self,
    settings: ChunkSettings
) -> Result<()>

Set the Chunk Settings used by the repository

pub async fn chunk_settings(&mut self) -> ChunkSettings

Gets the default Chunk Settings for the repository

pub async fn commit_archive(
    &mut self,
    repo: &mut Repository<impl BackendClone>,
    archive: ActiveArchive
) -> Result<()>

Commits an archive to the manifest, then the manifest to the repository

Consumes the repository while commiting it.

Panics

Will panic if commiting the archive to the repository fails

pub async fn archives(&mut self) -> Vec<StoredArchive>

Returns a copy of the list of archives in this repository

Theses can be converted into full archives with StoredArchive::load

pub async fn timestamp(&mut self) -> Result<DateTime<FixedOffset>>

Provides the timestamp of the manifest’s last modification

Trait Implementations

impl<T: Clone + Backend> Clone for Manifest<T> where
    T::Manifest: Clone, 

fn clone(&self) -> Manifest<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Backend> Debug for Manifest<T> where
    T::Manifest: Debug, 

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

Formats the value using the given formatter.

impl<'de, T: Backend> Deserialize<'de> for Manifest<T> where
    T::Manifest: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Backend> Serialize for Manifest<T> where
    T::Manifest: Serialize, 

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

Serialize this value into the given Serde serializer.