Struct ReadZipperOwned 

pub struct ReadZipperOwned<V: Clone + Send + Sync + 'static, A: Allocator + 'static = GlobalAlloc> { /* private fields */ }

A Zipper that holds ownership of the root node, so there is no need for a lifetime parameter

Implementations

impl<V: 'static + Clone + Send + Sync + Unpin, A: Allocator> ReadZipperOwned<V, A>

pub fn into_map(self) -> PathMap<V, A>

Consumes the zipper and returns a map contained within the zipper

Trait Implementations

impl<V: 'static + Clone + Send + Sync + Unpin, A: Allocator> Clone for ReadZipperOwned<V, A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Clone + Send + Sync + Unpin, A: Allocator> Debug for ReadZipperOwned<V, A>

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

Formats the value using the given formatter.

impl<V: Clone + Send + Sync + Unpin, A: Allocator> Zipper for ReadZipperOwned<V, A>

fn path_exists(&self) -> bool

Returns true if the zipper’s focus is on a path within the trie, otherwise false

fn is_val(&self) -> bool

Returns true if there is a value at the zipper’s focus, otherwise false

fn child_count(&self) -> usize

Returns the number of child branches from the focus node

fn child_mask(&self) -> ByteMask

Returns 256-bit mask indicating which children exist from the branch at the zipper’s focus

fn is_value(&self) -> bool

👎Deprecated

Deprecated alias for Zipper::is_val

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperAbsolutePath for ReadZipperOwned<V, A>

fn origin_path(&self) -> &[u8]

Returns the entire path from the zipper’s origin to its current focus

fn root_prefix_path(&self) -> &[u8]

Returns the path from the zipper’s origin to the zipper’s root

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperConcrete for ReadZipperOwned<V, A>

fn shared_node_id(&self) -> Option<u64>

Get an identifier unique to the node at the zipper’s focus, if the zipper’s focus is at the root of a node in memory. When zipper’s focus is inside of a node, returns None.

fn is_shared(&self) -> bool

Returns true if the zipper’s focus is at a location that may be accessed via two or more distinct paths

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperForking<V> for ReadZipperOwned<V, A>

type ReadZipperT<'a> = ReadZipperUntracked<'a, 'a, V, A> where Self: 'a

The read-zipper type returned from fork_read_zipper

fn fork_read_zipper<'a>(&'a self) -> Self::ReadZipperT<'a>

Returns a new read-only Zipper, with the new zipper’s root being at the zipper’s current focus

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperIteration for ReadZipperOwned<V, A>

fn to_next_val(&mut self) -> bool

Systematically advances to the next value accessible from the zipper, traversing in a depth-first order

fn descend_first_k_path(&mut self, k: usize) -> bool

Descends the zipper’s focus k bytes, following the first child at each branch, and continuing with depth-first exploration until a path that is k bytes from the focus has been found

fn to_next_k_path(&mut self, k: usize) -> bool

Moves the zipper’s focus to the next location with the same path length as the current focus, following a depth-first exploration from a common root k steps above the current focus

fn descend_last_path(&mut self) -> bool

Descends the zipper to the end of the last path (last by sort order) reachable by descent from the current focus.

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperMoving for ReadZipperOwned<V, A>

fn at_root(&self) -> bool

Returns true if the zipper’s focus is at its root, and it cannot ascend further, otherwise returns false

fn reset(&mut self)

Resets the zipper’s focus back to its root

fn path(&self) -> &[u8]

Returns the path from the zipper’s root to the current focus

fn val_count(&self) -> usize

Returns the total number of values contained at and below the zipper’s focus, including the focus itself

fn descend_to<K: AsRef<[u8]>>(&mut self, k: K)

Moves the zipper deeper into the trie, to the key specified relative to the current zipper focus

fn descend_to_check<K: AsRef<[u8]>>(&mut self, k: K) -> bool

Fused descend_to and path_exists. Moves the focus and returns whether or not the path exists at the new focus location

fn descend_to_existing<K: AsRef<[u8]>>(&mut self, k: K) -> usize

Moves the zipper deeper into the trie, following the path specified by k, relative to the current zipper focus. Descent stops at the point where the path does not exist

fn descend_to_val<K: AsRef<[u8]>>(&mut self, k: K) -> usize

Moves the zipper deeper into the trie, following the path specified by k, relative to the current zipper focus. Descent stops if a value is encountered or if the path ceases to exist.

fn descend_to_byte(&mut self, k: u8)

Moves the zipper one byte deeper into the trie. Identical in effect to descend_to with a 1-byte key argument

fn descend_to_existing_byte(&mut self, k: u8) -> bool

Moves the zipper one byte deeper into the trie, if the specified path byte exists in the child_mask.

fn descend_indexed_byte(&mut self, child_idx: usize) -> bool

Descends the zipper’s focus one byte into a child branch uniquely identified by child_idx

fn descend_first_byte(&mut self) -> bool

Descends the zipper’s focus one step into the first child branch in a depth-first traversal

fn descend_until(&mut self) -> bool

Descends the zipper’s focus until a branch or a value is encountered. Returns true if the focus moved otherwise returns false

fn to_next_sibling_byte(&mut self) -> bool

Moves the zipper’s focus to the next sibling byte with the same parent

fn to_prev_sibling_byte(&mut self) -> bool

Moves the zipper’s focus to the previous sibling byte with the same parent

fn ascend(&mut self, steps: usize) -> bool

Ascends the zipper steps steps. Returns true if the zipper sucessfully moved steps

fn ascend_byte(&mut self) -> bool

Ascends the zipper up a single byte. Equivalent to passing 1 to ascend

fn ascend_until(&mut self) -> bool

Ascends the zipper to the nearest upstream branch point or value. Returns true if the zipper focus moved upwards, otherwise returns false if the zipper was already at the root

fn ascend_until_branch(&mut self) -> bool

Ascends the zipper to the nearest upstream branch point, skipping over values along the way. Returns true if the zipper focus moved upwards, otherwise returns false if the zipper was already at the root

fn to_next_step(&mut self) -> bool

Advances the zipper to visit every existing path within the trie in a depth-first order

fn move_to_path<K: AsRef<[u8]>>(&mut self, path: K) -> usize

Moves the zipper’s focus to a specific location specified by path, relative to the zipper’s root

fn descend_to_value<K: AsRef<[u8]>>(&mut self, k: K) -> usize

👎Deprecated

Deprecated alias for ZipperMoving::descend_to_val

fn descend_indexed_branch(&mut self, idx: usize) -> bool

👎Deprecated

A deprecated alias for ZipperMoving::descend_indexed_byte

fn descend_last_byte(&mut self) -> bool

Descends the zipper’s focus one step into the last child branch

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperPathBuffer for ReadZipperOwned<V, A>

unsafe fn origin_path_assert_len(&self, len: usize) -> &[u8]

Internal method to get the path, beyond its length. Panics if len > the path’s capacity, or if the zipper is relative and doesn’t have an origin_path

fn prepare_buffers(&mut self)

Make sure the path buffer is allocated, to facilitate zipper movement

fn reserve_buffers(&mut self, path_len: usize, stack_depth: usize)

Reserve buffer space within the zipper’s path buffer and node stack

impl<'trie, V: Clone + Send + Sync + Unpin + 'trie, A: Allocator + 'trie> ZipperReadOnlyConditionalIteration<'trie, V> for ReadZipperOwned<V, A>

fn to_next_get_val_with_witness<'w>( &mut self, witness: &'w Self::WitnessT, ) -> Option<&'w V>

where 'a: 'w,

See ZipperReadOnlyIteration::to_next_get_val and witness

impl<'trie, V: Clone + Send + Sync + Unpin + 'trie, A: Allocator + 'trie> ZipperReadOnlyConditionalValues<'trie, V> for ReadZipperOwned<V, A>

type WitnessT = ReadZipperWitness<V, A>

The type that acts as a witness for the validity of the zipper

fn witness<'w>(&self) -> ReadZipperWitness<V, A>

Creates a witness that can allow acquisition of longer-lived borrows of values, while the zipper itself is mutated

fn get_val_with_witness<'w>( &self, witness: &'w ReadZipperWitness<V, A>, ) -> Option<&'w V>

where 'trie: 'w,

Returns a refernce to the value at the zipper’s focus, or None if there is no value

impl<'a, V: Clone + Send + Sync + Unpin, A: Allocator> ZipperReadOnlySubtries<'a, V, A> for ReadZipperOwned<V, A>

where Self: 'a,

type TrieRefT = TrieRefOwned<V, A>

The type of the returned TrieRef

fn trie_ref_at_path<K: AsRef<[u8]>>(&self, path: K) -> TrieRefOwned<V, A>

Returns a TrieRef for the specified path, relative to the current focus

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperSubtries<V, A> for ReadZipperOwned<V, A>

fn make_map(&self) -> Option<PathMap<Self::V, A>>

Returns a new PathMap containing everything below the zipper’s focus or None if no subtrie exists below the focus

impl<V: Clone + Send + Sync + Unpin, A: Allocator> ZipperValues<V> for ReadZipperOwned<V, A>

fn val(&self) -> Option<&V>

Returns a refernce to the value at the zipper’s focus, or None if there is no value

fn value(&self) -> Option<&V>

👎Deprecated

Deprecated alias for ZipperValues::val