Enum NodeType 

pub enum NodeType {
    Input,
    Output,
    Vertex,
    Edge,
    Leaf,
    Root,
}

NodeType is a soft identification for different nodes within a graph or tree structure.

Most of the time when reading a node’s type, we can determine what kind of node it is by the connections around it. For example, in a graph, if a node has 0 incoming connections, it is likely an Input. Inversely, if a node has 0 outgoing connections, it is likely an Output. For a tree, we can tell if it is a leaf or a vertex based on it’s nunmber of children. However, when building either a graph or tree, we usually want to specify which type of node we want to create. Thus, we typically use this enum more for writing (building nodes) rather than reading (traversing nodes).

See the GraphNode and TreeNode implementations for more details or rules around how this is handled.

Because of this, the NodeType enum is a soft identification, and should be used as a hint rather than a strict rule. The node_type method in the Node trait has guards around it within the GraphNode and TreeNode implementations which handle this ambiguity and provide a more accurate node type when traversing the graph or tree. All that being said, it is a very very rare case where the node_type method would return a different value than what is specified in the NodeType enum - the only way this is possible is if the NodeType isn’t supplied to the node during creation.

Within each node (GraphNode or TreeNode), the NodeType is used to determine the validity of the node given the value it holds.

Variants

Input

Input types are only used within graph structrues and are the starting point for data flow within the graph.

Output

Output types are only used within graph structrues and are the endpoint for data flow within the graph.

Vertex

Vertex types are used within both graph and tree structures to represent nodes that must have incoming (or parent) connections and outgoing connections (or children). This is a general purpose node type and is likely the type you think of when thinking of a generic node.

Edge

Edge types are only used within graph structures and represent nodes that have a single incoming connection and n outgoing connections. This is how we represent weights or other single-input nodes within a graph.

Leaf

Leaf types are used within tree structures to represent nodes that have no children. They are the endpoint (or output) of the tree structure. We use Leaf instead of output to avoid confusion and keep terminology consistent.

Root

Root types are used within tree structures to represent the starting point of the tree. They are the first node in the tree structure and must have 0 parents.

Trait Implementations

impl Clone for NodeType

fn clone(&self) -> NodeType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NodeType

impl Debug for NodeType

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

Formats the value using the given formatter.

impl Eq for NodeType

impl<T: Clone + Default> Factory<NodeType, Option<TreeNode<T>>> for NodeStore<T>

fn new_instance(&self, input: NodeType) -> Option<TreeNode<T>>

impl<T> Factory<NodeType, T> for NodeStore<T>

where T: Factory<(), T> + Default,

fn new_instance(&self, input: NodeType) -> T

impl Hash for NodeType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NodeType

fn cmp(&self, other: &NodeType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for NodeType

fn eq(&self, other: &NodeType) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for NodeType

fn partial_cmp(&self, other: &NodeType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for NodeType