Struct TreeNode 

#[non_exhaustive]
pub struct TreeNode<const N: usize> {
    pub references: u64,
    pub node: NodeVariant<TreeBranch<N>, TreeLeaf<N>, TreeData, N>,
}

A node in the tree.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

references: u64

The number of references to this node.

node: NodeVariant<TreeBranch<N>, TreeLeaf<N>, TreeData, N>

The NodeVariant of the node.

Trait Implementations

impl<const N: usize> Clone for TreeNode<N>

fn clone(&self) -> TreeNode<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Database<N, TreeNode<N>> for HashDB<N>

type EntryType = ([u8; N], Vec<u8>)

The type of entry for insertion. Primarily for convenience and tracking what goes into the database.

fn open(_path: &Path) -> Result<Self, Exception>

Opens an existing Database.

fn get_node(&self, key: Array<N>) -> Result<Option<TreeNode<N>>, Exception>

Gets a value from the database based on the given key.

fn insert(&mut self, key: Array<N>, value: TreeNode<N>) -> Result<(), Exception>

Queues a key and its associated value for insertion to the database.

fn remove(&mut self, key: &Array<N>) -> Result<(), Exception>

Removes a key and its associated value from the database.

fn batch_write(&mut self) -> Result<(), Exception>

Confirms previous inserts and writes the changes to the database.

impl<const N: usize> Debug for TreeNode<N>

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

Formats the value using the given formatter.

impl<const N: usize> Node<N> for TreeNode<N>

type Branch = TreeBranch<N>

The type of Branch for the Node

type Leaf = TreeLeaf<N>

The type of Leaf for the Node

type Data = TreeData

The type of Data for the Node

fn new( node_variant: NodeVariant<TreeBranch<N>, TreeLeaf<N>, TreeData, N>, ) -> Self

Creates a new Node.

fn get_references(&self) -> u64

Gets the number of references to this node.

fn get_variant(self) -> NodeVariant<TreeBranch<N>, TreeLeaf<N>, TreeData, N>

Decomposes the struct into its inner type.

fn set_references(&mut self, references: u64)

Sets the number of references to this node.

fn set_branch(&mut self, branch: TreeBranch<N>)

Sets the node to contain a Branch node. Mutually exclusive with set_data and set_leaf.

fn set_leaf(&mut self, leaf: TreeLeaf<N>)

Sets the node to contain a Leaf node. Mututally exclusive with set_data and set_branch.

fn set_data(&mut self, data: TreeData)

Sets the node to contain a Data node. Mutually exclusive with set_leaf and set_branch.

impl<const N: usize> PartialEq for TreeNode<N>

fn eq(&self, other: &TreeNode<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Eq for TreeNode<N>

impl<const N: usize> StructuralPartialEq for TreeNode<N>