Struct lb_rs::LazyTree

pub struct LazyTree<T>
where
    T: TreeLike,
{
    pub tree: T,
    pub name: HashMap<Uuid, String>,
    pub key: HashMap<Uuid, [u8; 32]>,
    pub implicit_deleted: HashMap<Uuid, bool>,
    pub children: HashMap<Uuid, HashSet<Uuid>>,
}

Fields

tree: T

name: HashMap<Uuid, String>

key: HashMap<Uuid, [u8; 32]>

implicit_deleted: HashMap<Uuid, bool>

children: HashMap<Uuid, HashSet<Uuid>>

Implementations

impl<T> LazyTree<T>

where T: TreeLike<F = ECSigned<FileMetadata>>,

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

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 ) -> Result<Vec<File>, SharedError>

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: [u8; 32], parent: &Uuid, name: &str, file_type: FileType, account: &Account ) -> Result<(ECSigned<FileMetadata>, Uuid), SharedError>

pub fn rename_op( &mut self, id: &Uuid, name: &str, account: &Account ) -> Result<ECSigned<FileMetadata>, SharedError>

pub fn move_op( &mut self, id: &Uuid, new_parent: &Uuid, account: &Account ) -> Result<Vec<ECSigned<FileMetadata>>, SharedError>

pub fn delete_op( &self, id: &Uuid, account: &Account ) -> Result<ECSigned<FileMetadata>, SharedError>

pub fn add_share_op( &mut self, id: Uuid, sharee: Owner, mode: ShareMode, account: &Account ) -> Result<ECSigned<FileMetadata>, SharedError>

pub fn delete_share_op( &mut self, id: &Uuid, maybe_encrypted_for: Option<PublicKey>, account: &Account ) -> Result<Vec<ECSigned<FileMetadata>>, SharedError>

pub fn read_document( &mut self, d: &impl DocumentService, id: &Uuid, account: &Account ) -> Result<Vec<u8>, SharedError>

pub fn update_document_op( &mut self, id: &Uuid, document: &[u8], account: &Account ) -> Result<(ECSigned<FileMetadata>, AESEncrypted<Vec<u8>>), SharedError>

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

where Staged: TreeLikeMut<F = ECSigned<FileMetadata>> + StagedTreeLike<Base = Base, Staged = Local>, Base: TreeLike<F = <Staged as TreeLike>::F>, Local: TreeLikeMut<F = <Staged as TreeLike>::F>,

pub fn create_unvalidated( &mut self, id: Uuid, key: [u8; 32], parent: &Uuid, name: &str, file_type: FileType, account: &Account ) -> Result<Uuid, SharedError>

pub fn create( &mut self, id: Uuid, key: [u8; 32], parent: &Uuid, name: &str, file_type: FileType, account: &Account ) -> Result<Uuid, SharedError>

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

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

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

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

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

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

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

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

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

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

pub fn update_document_unvalidated( &mut self, id: &Uuid, document: &[u8], account: &Account ) -> Result<AESEncrypted<Vec<u8>>, SharedError>

pub fn update_document( &mut self, id: &Uuid, document: &[u8], account: &Account ) -> Result<AESEncrypted<Vec<u8>>, SharedError>

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

impl<T> LazyTree<T>

where T: TreeLike,

pub fn new(tree: T) -> LazyTree<T>

impl<T> LazyTree<T>

where T: TreeLike,

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

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

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

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

pub fn decrypt_key( &mut self, id: &Uuid, account: &Account ) -> Result<[u8; 32], SharedError>

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

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

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

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

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

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 ) -> Result<HashSet<Uuid>, SharedError>

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

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 ) -> Result<HashSet<Uuid>, SharedError>

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

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: &AESEncrypted<Vec<u8>>, account: &Account ) -> Result<Vec<u8>, SharedError>

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

where T2: TreeLikeMut<F = <T as TreeLike>::F>,

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

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

impl<T> LazyTree<T>

where T: TreeLikeMut,

pub fn stage_and_promote<S>(&mut self, staged: S) -> Result<(), SharedError>

where S: TreeLikeMut<F = <T as TreeLike>::F>,

pub fn stage_validate_and_promote<S>( &mut self, staged: S, owner: Owner ) -> Result<(), SharedError>

where S: TreeLikeMut<F = <T as TreeLike>::F>,

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

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

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

pub fn promote(self) -> Result<LazyTree<Base>, SharedError>

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

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

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

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

where Base: TreeLike<F = ECSigned<FileMetadata>>, Local: TreeLike<F = <Base as TreeLike>::F>,

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

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

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

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

where Base: TreeLike<F = ECSigned<FileMetadata>>, Local: TreeLikeMut<F = <Base as TreeLike>::F>,

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

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

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

pub fn stage_diff( self, changes: Vec<FileDiff<ECSigned<FileMetadata>>> ) -> Result<LazyTree<StagedTree<ServerTree<'a>, Vec<ServerFile>>>, SharedError>

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

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

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

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

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

pub fn assert_all_filenames_size_limit(&self) -> Result<(), SharedError>

pub fn assert_only_folders_have_children(&self) -> Result<(), SharedError>

pub fn assert_all_files_same_owner_as_parent( &mut self ) -> Result<(), SharedError>

pub fn assert_no_cycles(&mut self) -> Result<(), SharedError>

pub fn assert_no_path_conflicts(&mut self) -> Result<(), SharedError>

pub fn assert_no_shared_links(&self) -> Result<(), SharedError>

pub fn assert_no_duplicate_links(&mut self) -> Result<(), SharedError>

pub fn assert_no_broken_links(&mut self) -> Result<(), SharedError>

pub fn assert_no_owned_links(&self) -> Result<(), SharedError>

pub fn assert_no_root_changes(&mut self) -> Result<(), SharedError>

pub fn assert_no_changes_to_deleted_files(&mut self) -> Result<(), SharedError>

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

Trait Implementations

impl<T> Debug for LazyTree<T>

where T: Debug + TreeLike,

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

Formats the value using the given formatter.

impl<T> TreeLike for LazyTree<T>

where T: TreeLike,

type F = <T as TreeLike>::F

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

fn maybe_find(&self, id: &Uuid) -> Option<&<LazyTree<T> as TreeLike>::F>

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

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

where F2: FileLike,

fn find_parent<F2>(&self, file: &F2) -> Result<&Self::F, SharedError>

where F2: FileLike,

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

fn all_files(&self) -> Result<Vec<&Self::F>, SharedError>

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>