Struct StagedTree

pub struct StagedTree<Base, Staged>
where
    Base: TreeLike,
    Staged: TreeLike<F = Base::F>,
{
    pub base: Base,
    pub staged: Staged,
    pub removed: HashSet<Uuid>,
}

Fields

base: Base

staged: Staged

removed: HashSet<Uuid>

Implementations

impl<Base, Staged> StagedTree<Base, Staged>

where Base: TreeLike, Staged: TreeLike<F = Base::F>,

pub fn new(base: Base, staged: Staged) -> Self

impl<Base> StagedTree<Base, Option<Base::F>>

where Base: TreeLike,

pub fn removal(base: Base, removed: HashSet<Uuid>) -> Self

Trait Implementations

impl<Base, Staged> Debug for StagedTree<Base, Staged>

where Base: TreeLike + Debug, Staged: TreeLike<F = Base::F> + Debug,

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

Formats the value using the given formatter.

impl<Base, Staged> StagedTreeLike for StagedTree<Base, Staged>

where Base: TreeLike, Staged: TreeLike<F = Base::F>,

type Base = Base

type Staged = Staged

fn base(&self) -> &Self::Base

fn staged(&self) -> &Self::Staged

impl<Base, Staged> StagedTreeLikeMut<Base, Staged> for StagedTree<Base, Staged>

where Base: TreeLike, Staged: TreeLikeMut<F = Base::F>,

fn staged_mut(&mut self) -> &mut Self::Staged

fn prune(&mut self) -> SharedResult<()>

fn pruned(self) -> SharedResult<Self>

impl<Base, Staged> TreeLike for StagedTree<Base, Staged>

where Base: TreeLike, Staged: TreeLike<F = Base::F>,

type F = <Base as TreeLike>::F

fn ids(&self) -> HashSet<&Uuid>

fn maybe_find(&self, id: &Uuid) -> Option<&Self::F>

fn find(&self, id: &Uuid) -> SharedResult<&Self::F>

fn maybe_find_parent<F2: FileLike>(&self, file: &F2) -> Option<&Self::F>

fn find_parent<F2: FileLike>(&self, file: &F2) -> SharedResult<&Self::F>

fn owned_ids(&self) -> HashSet<Uuid>

fn all_files(&self) -> SharedResult<Vec<&Self::F>>

fn stage<Staged>(&self, staged: Staged) -> StagedTree<&Self, Staged>

where Staged: TreeLike<F = Self::F>, Self: Sized,

fn to_staged<Staged>(self, staged: Staged) -> StagedTree<Self, Staged>

where Staged: TreeLike<F = Self::F>, Self: Sized,

fn as_lazy(&self) -> LazyTree<&Self>

fn to_lazy(self) -> LazyTree<Self>

impl<Base, Staged> TreeLikeMut for StagedTree<Base, Staged>

where Base: TreeLike, Staged: TreeLikeMut<F = Base::F>,

fn insert(&mut self, f: Self::F) -> SharedResult<Option<Self::F>>

fn remove(&mut self, id: Uuid) -> SharedResult<Option<Self::F>>

fn clear(&mut self) -> SharedResult<()>