Struct Tree

pub struct Tree(/* private fields */);

Implementations

impl Tree

pub fn insert_directory<'a>(&self, path: &'a str) -> Result<'a, ()>

Create a new directory at path, creating all entries in between

pub fn insert_file<'a>(&self, path: &'a str, file: Entry) -> Result<'a, ()>

Insert or overwrite an file at path, creating all entries in between

pub fn update_file<'a>(&self, path: &'a str, file: Entry) -> Result<'a, ()>

Updates an file at path

pub fn remove<'a>(&self, path: &'a str) -> Result<'a, ()>

Recursively remove a subtree the path

pub fn file<'a>(&self, path: &'a str) -> Result<'a, Option<Arc<Entry>>>

Return a file

pub fn node_by_ref(&self, noderef: &Digest) -> Option<Arc<Node>>

pub fn node_by_path<'a>(&self, path: &'a str) -> Result<'a, Option<Arc<Node>>>

Return a file system node

pub fn move_node<'a>( &self, old_path: &'a str, new_path: &'a str, ) -> Result<'a, ()>

Move the file from the old path to the new path in the tree

pub fn is_file<'a>(&self, path: &'a str) -> Result<'a, bool>

Returns if the path is a file

pub fn retain<F>(&self, f: F)

where F: FnMut(&str, &Node) -> bool,

pub fn iter_files(&self) -> TreeIterator<'_>

pub fn clear(&self) -> usize

Trait Implementations

impl Clone for Tree

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Collection for Tree

type Depth = Incremental

Use this strategy to load the collection.

type Key = <VersionedMap<[u8; 32], Node> as Collection>::Key

The key that the predicate will use to decide whether to pull more data into memory.

type Serialized = <VersionedMap<[u8; 32], Node> as Collection>::Serialized

The serialized record format. This type will typically implement serde::Serialize

type Item = <VersionedMap<[u8; 32], Node> as Collection>::Item

This is equivalent to Iterator::Item, and should contain a full record that can be inserted into the in-memory store.

fn key(from: &Self::Serialized) -> &Self::Key

Get the key based on the deserialized data. You want this to be a reference that’s easy to derive from the serialized data.

fn load(from: Self::Serialized, object: &mut dyn Reader) -> Self::Item

Load the full record, and return it

fn insert(&mut self, record: Self::Item)

Store the deserialized record in the collection

impl Default for Tree

fn default() -> Tree

Returns the “default value” for a type.

impl Store for Tree

fn store(&mut self, transaction: &mut dyn Transaction, object: &mut dyn Writer)

Store the contents of the field into the index. The field itself needs to track whether this should be a complete rewrite or an upsert.