Trait NodeStore 

pub trait NodeStore: HasNodeStore {
    // Provided methods
    fn nodes_len(&self) -> usize { ... }
    fn max_node_depth(&mut self) -> usize
       where Self: Sized { ... }
    fn is_nodes_empty(&self) -> bool { ... }
    fn has_node(&self, id: &Uuid) -> bool { ... }
    fn add_node(
        &mut self,
        node: Node,
        safe: bool,
    ) -> Result<Option<Node>, NodeStoreError>
       where Self: Sized { ... }
    fn extend_nodes(
        &mut self,
        nodes: Vec<Node>,
        safe: bool,
    ) -> Result<Vec<Node>, NodeStoreError>
       where Self: Sized { ... }
    fn check_node(&self, node: &Node) -> Result<(), NodeStoreError>
       where Self: Sized { ... }
    fn get_node(&self, id: &Uuid) -> Option<&Node> { ... }
    fn get_node_err(&self, id: &Uuid) -> Result<&Node, NodeStoreError> { ... }
    fn get_node_mut(&mut self, node_id: &Uuid) -> Option<&mut Node> { ... }
    fn del_node(&mut self, node_id: &Uuid) -> Option<Node> { ... }
    fn calculate_node_depth(&self) -> usize
       where Self: Sized { ... }
    fn all_node_ids(&self) -> impl Iterator<Item = Uuid> { ... }
    fn all_nodes(&self) -> impl Iterator<Item = &Node> { ... }
    fn root_ids(&self) -> impl Iterator<Item = Uuid> { ... }
    fn root_nodes(&self) -> impl Iterator<Item = &Node> { ... }
    fn leaf_ids(&self) -> impl Iterator<Item = Uuid> { ... }
    fn leaf_nodes(&self) -> impl Iterator<Item = &Node> { ... }
    fn set_parent(
        &mut self,
        child_id: &Uuid,
        parent_id: Option<&Uuid>,
    ) -> Result<(), NodeStoreError> { ... }
    fn set_bus(
        &mut self,
        node_id: &Uuid,
        is_bus: bool,
    ) -> Result<(), NodeStoreError> { ... }
    fn bus_ids(
        &self,
        parent_id: &Uuid,
    ) -> Result<impl Iterator<Item = Uuid>, NodeStoreError> { ... }
    fn bus_nodes(
        &self,
        parent_id: &Uuid,
    ) -> Result<impl Iterator<Item = &Node>, NodeStoreError> { ... }
    fn ascendant_ids<'a, 'n>(
        &'n self,
        node_id: &'a Uuid,
        safe: bool,
        only_root: bool,
        root_ids: Option<&'a BTreeSet<Uuid>>,
        height: Option<usize>,
    ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>
       where Self: Sized { ... }
    fn ascendant_nodes<'a, 'n>(
        &'n self,
        node_id: &'a Uuid,
        safe: bool,
        only_root: bool,
        root_ids: Option<&'a BTreeSet<Uuid>>,
        height: Option<usize>,
    ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>
       where Self: Sized { ... }
    fn node_depth(
        &self,
        node_id: &Uuid,
        safe: bool,
        root_ids: Option<&BTreeSet<Uuid>>,
        height: Option<usize>,
    ) -> Result<usize, NodeStoreError>
       where Self: Sized { ... }
    fn descendant_ids<'a, 'n>(
        &'n self,
        node_id: &'a Uuid,
        safe: bool,
        only_leaf: bool,
        leaf_ids: Option<&'a BTreeSet<Uuid>>,
        depth: Option<usize>,
    ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>
       where Self: Sized { ... }
    fn descendant_nodes<'a, 'n>(
        &'n self,
        node_id: &'a Uuid,
        safe: bool,
        only_leaf: bool,
        leaf_ids: Option<&'a BTreeSet<Uuid>>,
        depth: Option<usize>,
    ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>
       where Self: Sized { ... }
    fn node_height(
        &self,
        node_id: &Uuid,
        safe: bool,
        leaf_ids: Option<&BTreeSet<Uuid>>,
        depth: Option<usize>,
    ) -> Result<usize, NodeStoreError>
       where Self: Sized { ... }
    fn node_width(
        &self,
        node_id: &Uuid,
        safe: bool,
        leaf_ids: Option<&BTreeSet<Uuid>>,
        depth: Option<usize>,
    ) -> Result<usize, NodeStoreError>
       where Self: Sized { ... }
    fn node_aggregate(&self) -> &Aggregate { ... }
}

Provided Methods

fn nodes_len(&self) -> usize

The number of nodes in this store.

fn max_node_depth(&mut self) -> usize

where Self: Sized,

Maximum node depth or height.

fn is_nodes_empty(&self) -> bool

Whether this node store is empty.

fn has_node(&self, id: &Uuid) -> bool

Check whether this store contains a node with the given node ID.

fn add_node( &mut self, node: Node, safe: bool, ) -> Result<Option<Node>, NodeStoreError>

where Self: Sized,

Add a single node to this store. Setting ‘safe’ checks whether this node’s references exist and detects cyclic hierarchies.

fn extend_nodes( &mut self, nodes: Vec<Node>, safe: bool, ) -> Result<Vec<Node>, NodeStoreError>

where Self: Sized,

Extend this node store with new nodes. Setting ‘safe’ checks whether all node references exist and detects cyclic hierarchies after adding them to the store first.

fn check_node(&self, node: &Node) -> Result<(), NodeStoreError>

where Self: Sized,

Check whether a node’s references exist and it doesn’t partake in cyclic hierarchies.

fn get_node(&self, id: &Uuid) -> Option<&Node>

Get a reference to a node.

fn get_node_err(&self, id: &Uuid) -> Result<&Node, NodeStoreError>

Get a reference to a node as as result.

fn get_node_mut(&mut self, node_id: &Uuid) -> Option<&mut Node>

Get a mutable reference to a node.

fn del_node(&mut self, node_id: &Uuid) -> Option<Node>

Delete node from this store.

fn calculate_node_depth(&self) -> usize

where Self: Sized,

Update max node depth.

fn all_node_ids(&self) -> impl Iterator<Item = Uuid>

Get all node IDs in this store.

fn all_nodes(&self) -> impl Iterator<Item = &Node>

Get all node IDs in this store.

fn root_ids(&self) -> impl Iterator<Item = Uuid>

Get all root node IDs in this store.

fn root_nodes(&self) -> impl Iterator<Item = &Node>

Get all root nodes in this store.

fn leaf_ids(&self) -> impl Iterator<Item = Uuid>

Get all leaf node IDs in this store.

fn leaf_nodes(&self) -> impl Iterator<Item = &Node>

Get all leaf nodes in this store.

fn set_parent( &mut self, child_id: &Uuid, parent_id: Option<&Uuid>, ) -> Result<(), NodeStoreError>

Set a new parent value for the given child ID. Returns an error if the child node does not exist in the store. Setting the parent ID to None removes the parent-child relationship.

fn set_bus( &mut self, node_id: &Uuid, is_bus: bool, ) -> Result<(), NodeStoreError>

Set the is_bus value of a given node ID.

fn bus_ids( &self, parent_id: &Uuid, ) -> Result<impl Iterator<Item = Uuid>, NodeStoreError>

Get the bus node IDs that fall directly under the given parent ID.

fn bus_nodes( &self, parent_id: &Uuid, ) -> Result<impl Iterator<Item = &Node>, NodeStoreError>

Get the bus nodes that fall directly under the given parent ID.

fn ascendant_ids<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_root: bool, root_ids: Option<&'a BTreeSet<Uuid>>, height: Option<usize>, ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>

where Self: Sized,

Get ascendant node IDs of a given node. Setting safe checks for cyclic hierarchies along the way. only_root only includes the final root node. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn ascendant_nodes<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_root: bool, root_ids: Option<&'a BTreeSet<Uuid>>, height: Option<usize>, ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>

where Self: Sized,

Get ascendant nodes of a given node. Setting safe checks for cyclic hierarchies along the way. only_root only includes the final root node. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn node_depth( &self, node_id: &Uuid, safe: bool, root_ids: Option<&BTreeSet<Uuid>>, height: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node depth (i.e. the number of levels that exist above). Setting safe checks for cyclic hierarchies along the way. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn descendant_ids<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_leaf: bool, leaf_ids: Option<&'a BTreeSet<Uuid>>, depth: Option<usize>, ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>

where Self: Sized,

Get the descendant node IDs of a given node. Setting safe checks for cyclic hierarchies. Setting only_leaf only includes only absolute or specified leaf nodes in the result. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth at which nodes are also considered leaf nodes for this search.

fn descendant_nodes<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_leaf: bool, leaf_ids: Option<&'a BTreeSet<Uuid>>, depth: Option<usize>, ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>

where Self: Sized,

Get the descendant nodes of a given node. Setting safe checks for cyclic hierarchies. Setting only_leaf only includes only absolute or specified leaf nodes in the result. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_height( &self, node_id: &Uuid, safe: bool, leaf_ids: Option<&BTreeSet<Uuid>>, depth: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node height (i.e. the number of levels that exist below). Setting safe checks for cyclic hierarchies. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_width( &self, node_id: &Uuid, safe: bool, leaf_ids: Option<&BTreeSet<Uuid>>, depth: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node width in terms of (optionally specified) leaf nodes. Setting safe checks for cyclic hierarchies. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_aggregate(&self) -> &Aggregate

Get the aggregate.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl NodeStore for Graph

impl NodeStore for NodeStoreData