Struct hua_core::store::Store

pub struct Store<S, B, const BAR: bool = true> { /* private fields */ }

A Store that contains all the packages installed by any user Content Addressable Store

Implementations

impl<B> Store<Url, B>

pub fn url(&self) -> &Url

impl Store<(), MemoryBackend>

pub fn init() -> Result<Self, StoreError>

impl<B: ReadBackend<Source = Url>> Store<Url, B>

pub fn open(url: Url) -> Result<Self, StoreError>

impl<B> Store<PathBuf, B>

pub fn path(&self) -> &Path

impl<B: ReadBackend<Source = PathBuf>> Store<PathBuf, B>

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, StoreError>

Opens a store under the specified path. Returns an error if the path does not exists or does not contain the necessary files

pub fn link_package(
    &self,
    package_id: &PackageId,
    to: &ComponentPathBuf
) -> Result<(), StoreError>

Links only the package at the specified path. If the package itself has object linked to other packages, link to the link.

pub fn link_packages<'a>(
    &self,
    indices: impl IntoIterator<Item = &'a PackageId>,
    to: &ComponentPathBuf
) -> Result<(), StoreError>

Links all the packages to the specified path.

impl<B: WriteBackend<Source = PathBuf>> Store<PathBuf, B>

pub fn init<P: AsRef<Path>>(path: P) -> Result<Self, StoreError>

Creates a new store directory under the given path. Will return an Error if the directory already exists

impl<S, B: ReadBackend, const BAR: bool> Store<S, B, BAR>

pub fn packages(&self) -> &Packages

pub fn objects(&self) -> &Objects

pub fn matches<'a>(
    &'a self,
    requirement: &'a Requirement
) -> impl Iterator<Item = (&'a PackageId, &'a Derivation, impl Iterator<Item = &'a Blob>)> + '_

pub fn is_matching(
    &self,
    package_id: &PackageId,
    requirement: &Requirement
) -> bool

pub fn get_blobs_of_package<'a>(
    &'a self,
    package_id: &PackageId
) -> Option<impl Iterator<Item = &'a Blob>>

pub fn get_blobs_cloned_of_package(
    &self,
    package_id: &PackageId
) -> Option<impl Iterator<Item = Blob> + '_>

impl<S, B: WriteBackend, const BAR: bool> Store<S, B, BAR>

pub fn objects_mut(&mut self) -> &mut Objects

pub fn packages_mut(&mut self) -> &mut Packages

impl<B: WriteBackend<Source = PathBuf> + ReadBackend<Source = PathBuf>, const BAR: bool> Store<PathBuf, B, BAR>

pub fn insert_remote(
    &mut self,
    source: RemotePackageSource
) -> Result<PathBuf, StoreError>

pub fn insert(
    &mut self,
    source: LocalPackageSource
) -> Result<PathBuf, StoreError>

Inserts a package into the store and returns true if the package was not present and was inserted and false if it was already present.

pub fn extend<'a>(
    &'a mut self,
    packages: impl IntoIterator<Item = LocalPackageSource> + 'a
) -> impl Iterator<Item = Result<PathBuf, StoreError>> + 'a

pub fn remove_unused(
    &mut self,
    user_manager: &UserManager
) -> Result<Vec<PackageId>, StoreError>

Remove all packages that are currently unused in all generations.

pub fn flush(self) -> Result<(), StoreError>

Flushes all data to the backend

Trait Implementations

impl<S: Debug, B: Debug, const BAR: bool> Debug for Store<S, B, BAR>

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

Formats the value using the given formatter.