Struct LazyTree

pub struct LazyTree<T: TreeLike> {
    pub tree: T,
    pub name: HashMap<Uuid, String>,
    pub key: HashMap<Uuid, AESKey>,
    pub implicit_deleted: HashMap<Uuid, bool>,
    pub children: HashMap<Uuid, HashSet<Uuid>>,
}

Fields

tree: T

name: HashMap<Uuid, String>

key: HashMap<Uuid, AESKey>

implicit_deleted: HashMap<Uuid, bool>

children: HashMap<Uuid, HashSet<Uuid>>

Implementations

impl<T> LazyTree<T>

where T: TreeLike<F = SignedFile>,

pub fn decrypt( &mut self, account: &Account, id: &Uuid, public_key_cache: &mut LookupTable<Owner, String>, ) -> SharedResult<File>

convert FileMetadata into File. fields have been decrypted, public keys replaced with usernames, deleted files filtered out, etc.

pub fn decrypt_all<I>( &mut self, account: &Account, ids: I, public_key_cache: &mut LookupTable<Owner, String>, skip_invisible: bool, ) -> SharedResult<Vec<File>>

where I: Iterator<Item = Uuid>,

convert FileMetadata into File. fields have been decrypted, public keys replaced with usernames, deleted files filtered out, etc.

pub fn create_op( &mut self, id: Uuid, key: AESKey, parent: &Uuid, name: &str, file_type: FileType, account: &Account, ) -> SharedResult<(SignedFile, Uuid)>

pub fn rename_op( &mut self, id: &Uuid, name: &str, account: &Account, ) -> SharedResult<SignedFile>

pub fn move_op( &mut self, id: &Uuid, new_parent: &Uuid, account: &Account, ) -> SharedResult<Vec<SignedFile>>

pub fn delete_op( &self, id: &Uuid, account: &Account, ) -> SharedResult<SignedFile>

pub fn add_share_op( &mut self, id: Uuid, sharee: Owner, mode: ShareMode, account: &Account, ) -> SharedResult<SignedFile>

pub fn delete_share_op( &mut self, id: &Uuid, maybe_encrypted_for: Option<PublicKey>, account: &Account, ) -> SharedResult<Vec<SignedFile>>

pub fn read_document( &mut self, d: &impl DocumentService, id: &Uuid, account: &Account, ) -> SharedResult<DecryptedDocument>

pub fn update_document_op( &mut self, id: &Uuid, document: &[u8], account: &Account, ) -> SharedResult<(SignedFile, EncryptedDocument)>

impl<Base, Local, Staged> LazyTree<Staged>

where Staged: StagedTreeLike<Base = Base, Staged = Local, F = SignedFile> + TreeLikeMut, Base: TreeLike<F = Staged::F>, Local: TreeLikeMut<F = Staged::F>,

pub fn create_unvalidated( &mut self, id: Uuid, key: AESKey, parent: &Uuid, name: &str, file_type: FileType, account: &Account, ) -> SharedResult<Uuid>

pub fn create( &mut self, id: Uuid, key: AESKey, parent: &Uuid, name: &str, file_type: FileType, account: &Account, ) -> SharedResult<Uuid>

pub fn rename_unvalidated( &mut self, id: &Uuid, name: &str, account: &Account, ) -> SharedResult<()>

pub fn rename( &mut self, id: &Uuid, name: &str, account: &Account, ) -> SharedResult<()>

pub fn move_unvalidated( &mut self, id: &Uuid, new_parent: &Uuid, account: &Account, ) -> SharedResult<()>

pub fn move_file( &mut self, id: &Uuid, new_parent: &Uuid, account: &Account, ) -> SharedResult<()>

pub fn delete_unvalidated( &mut self, id: &Uuid, account: &Account, ) -> SharedResult<()>

pub fn delete(&mut self, id: &Uuid, account: &Account) -> SharedResult<()>

pub fn add_share_unvalidated( &mut self, id: Uuid, sharee: Owner, mode: ShareMode, account: &Account, ) -> SharedResult<()>

pub fn add_share( &mut self, id: Uuid, sharee: Owner, mode: ShareMode, account: &Account, ) -> SharedResult<()>

pub fn delete_share_unvalidated( &mut self, id: &Uuid, maybe_encrypted_for: Option<PublicKey>, account: &Account, ) -> SharedResult<()>

pub fn delete_share( &mut self, id: &Uuid, maybe_encrypted_for: Option<PublicKey>, account: &Account, ) -> SharedResult<()>

pub fn update_document_unvalidated( &mut self, id: &Uuid, document: &[u8], account: &Account, ) -> SharedResult<EncryptedDocument>

pub fn update_document( &mut self, id: &Uuid, document: &[u8], account: &Account, ) -> SharedResult<EncryptedDocument>

pub fn delete_unreferenced_file_versions( &self, docs: &impl DocumentService, ) -> SharedResult<()>

impl<T: TreeLike> LazyTree<T>

pub fn new(tree: T) -> Self

impl<T: TreeLike> LazyTree<T>

pub fn access_mode( &self, owner: Owner, id: &Uuid, ) -> SharedResult<Option<UserAccessMode>>

pub fn in_pending_share(&mut self, id: &Uuid) -> SharedResult<bool>

pub fn all_children(&mut self) -> SharedResult<&HashMap<Uuid, HashSet<Uuid>>>

pub fn calculate_deleted(&mut self, id: &Uuid) -> SharedResult<bool>

pub fn decrypt_key( &mut self, id: &Uuid, account: &Account, ) -> SharedResult<AESKey>

pub fn name(&mut self, id: &Uuid, account: &Account) -> SharedResult<String>

pub fn name_using_links( &mut self, id: &Uuid, account: &Account, ) -> SharedResult<String>

pub fn parent_using_links(&mut self, id: &Uuid) -> SharedResult<Uuid>

pub fn linked_by(&mut self, id: &Uuid) -> SharedResult<Option<Uuid>>

pub fn children(&mut self, id: &Uuid) -> SharedResult<HashSet<Uuid>>

Returns ids of files whose parent is the argument. Does not include the argument. TODO could consider returning a reference to the underlying cached value

pub fn children_using_links(&mut self, id: &Uuid) -> SharedResult<HashSet<Uuid>>

pub fn descendants(&mut self, id: &Uuid) -> SharedResult<HashSet<Uuid>>

Returns ids of files for which the argument is an ancestor—the files’ children, recursively. Does not include the argument. This function tolerates cycles.

pub fn descendants_using_links( &mut self, id: &Uuid, ) -> SharedResult<HashSet<Uuid>>

pub fn ancestors(&self, id: &Uuid) -> SharedResult<HashSet<Uuid>>

Returns ids of files for which the argument is a descendent—the files’ parent, recursively. Does not include the argument. This function tolerates cycles.

pub fn decrypt_document( &mut self, id: &Uuid, encrypted: &EncryptedDocument, account: &Account, ) -> SharedResult<DecryptedDocument>

pub fn stage<T2: TreeLikeMut<F = T::F>>( self, staged: T2, ) -> LazyTree<StagedTree<T, T2>>

pub fn stage_removals( self, removed: HashSet<Uuid>, ) -> LazyTree<StagedTree<T, Option<T::F>>>

pub fn assert_names_decryptable( &mut self, account: &Account, ) -> SharedResult<()>

impl<T> LazyTree<T>

where T: TreeLikeMut,

pub fn stage_and_promote<S: TreeLikeMut<F = T::F>>( &mut self, staged: S, ) -> SharedResult<()>

pub fn stage_validate_and_promote<S: TreeLikeMut<F = T::F>>( &mut self, staged: S, owner: Owner, ) -> SharedResult<()>

pub fn stage_removals_and_promote( &mut self, removed: HashSet<Uuid>, ) -> SharedResult<()>

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

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

pub fn promote(self) -> SharedResult<LazyTree<Base>>

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

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

pub fn unstage(self) -> (LazyTree<Base>, Staged)

impl<Base, Local> LazyTree<StagedTree<Base, Local>>

where Base: TreeLike<F = SignedFile>, Local: TreeLike<F = Base::F>,

pub fn path_to_id( &mut self, path: &str, root: &Uuid, account: &Account, ) -> SharedResult<Uuid>

pub fn id_to_path( &mut self, id: &Uuid, account: &Account, ) -> SharedResult<String>

pub fn list_paths( &mut self, filter: Option<Filter>, account: &Account, ) -> SharedResult<Vec<String>>

impl<Base, Local> LazyTree<StagedTree<Base, Local>>

where Base: TreeLike<F = SignedFile>, Local: TreeLikeMut<F = Base::F>,

pub fn create_link_at_path( &mut self, path: &str, target_id: Uuid, root: &Uuid, account: &Account, pub_key: &PublicKey, ) -> SharedResult<Uuid>

pub fn create_at_path( &mut self, path: &str, root: &Uuid, account: &Account, pub_key: &PublicKey, ) -> SharedResult<Uuid>

impl<'a> LazyTree<ServerTree<'a>>

pub fn stage_diff( self, changes: Vec<FileDiff<SignedFile>>, ) -> SharedResult<LazyStaged1<ServerTree<'a>, Vec<ServerFile>>>

Validates a diff prior to staging it. Performs individual validations, then validations that require a tree

impl<T, Base, Local> LazyTree<T>

where T: StagedTreeLike<Base = Base, Staged = Local>, Base: TreeLike<F = T::F>, Local: TreeLike<F = T::F>,

pub fn validate(&mut self, owner: Owner) -> SharedResult<()>

pub fn assert_all_files_decryptable(&mut self, owner: Owner) -> SharedResult<()>

pub fn assert_all_filenames_size_limit(&self) -> SharedResult<()>

pub fn assert_only_folders_have_children(&self) -> SharedResult<()>

pub fn assert_all_files_same_owner_as_parent(&mut self) -> SharedResult<()>

pub fn assert_no_cycles(&mut self) -> SharedResult<()>

pub fn assert_no_path_conflicts(&mut self) -> SharedResult<()>

pub fn assert_no_shared_links(&self) -> SharedResult<()>

pub fn assert_no_duplicate_links(&mut self) -> SharedResult<()>

pub fn assert_no_broken_links(&mut self) -> SharedResult<()>

pub fn assert_no_owned_links(&self) -> SharedResult<()>

pub fn assert_no_root_changes(&mut self) -> SharedResult<()>

pub fn assert_no_changes_to_deleted_files(&mut self) -> SharedResult<()>

pub fn assert_changes_authorized(&mut self, owner: Owner) -> SharedResult<()>

Trait Implementations

impl<T: Debug + TreeLike> Debug for LazyTree<T>

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

Formats the value using the given formatter.

impl<T: TreeLike> TreeLike for LazyTree<T>

type F = <T 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>