Struct narwhal_dag::Node

pub struct Node<T> { /* private fields */ }

The Dag node, aka vertex.

Implementations

impl<T> Node<T>

pub fn new_leaf(value: T, compressible: bool) -> Self

Create a new DAG leaf node that contains the given value.

Example

use narwhal_dag::{ Node, NodeRef };

let node = Node::new_leaf(1, false);

pub fn new(value: T, compressible: bool, parents: Vec<NodeRef<T>>) -> Self

Create a new DAG inner node that contains the given value and points to the given parents.

pub fn value(&self) -> &T

Return the value payload of the node

Example

use narwhal_dag::Node;

let node = Node::new_leaf(1, false);
assert_eq!(*node.value(), 1);

pub fn is_leaf(&self) -> bool

Is the node parent-less?

Examples

use narwhal_dag::Node;

let node = Node::new_leaf(1, false);
assert_eq!(node.is_leaf(), true);

pub fn is_compressible(&self) -> bool

Is the node compressible?

Examples

use narwhal_dag::Node;

let node = Node::new_leaf(1, true);
assert_eq!(node.is_compressible(), true);

pub fn make_compressible(&self) -> bool

Make the node compressible. Returns true if the node was made compressible, false if it already was.

Beware: this operation is irreversible.

Examples

use narwhal_dag::Node;

let node = Node::new_leaf(1, false);
assert_eq!(node.make_compressible(), true);
let node2 = Node::new_leaf(2, true);
assert_eq!(node.make_compressible(), false);

impl<T: Sync + Send + Debug> Node<T>

pub fn parents(&self) -> Vec<NodeRef<T>>

Compress the path from this node to the next incompressible layer of the DAG. Returns the parents of the node.

After path compression, one of these three conditions holds:

• This node is a leaf node;
• This node has only incompressible parents, and keeps them;
• This node has compressible parents, and after path compression, they are replaced by their closest incompressible ancestors.

Trait Implementations

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<T> From<Node<T>> for NodeRef<T>

fn from(node: Node<T>) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq<Node<T>> for Node<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq> Eq for Node<T>