Struct Tree 

pub struct Tree<Inner>
where
    Inner: MutableGraph,
{ /* private fields */ }

A tree is a directed graph in which there is exactly one path between any two nodes.

A tree always has a root node, which is the only node that has no incoming edges.

Implementations

impl<Inner> Tree<Inner>

where Inner: MutableGraph,

pub fn new_unchecked(root: NodeID, graph: Inner) -> Self

pub fn new_with_root_and_graph(root: NodeID, graph: Inner) -> Result<Self>

pub fn graph(&self) -> &Inner

impl<Inner> Tree<Inner>

where Inner: MutableGraph + Default + Clone, Inner::NData: Default,

pub fn new_with_root(root: NodeID) -> Self

pub fn new() -> Self

impl<Inner> Tree<Inner>

where Inner: MutableGraph + Serialize,

pub fn to_json(&self) -> String

impl<'de, Inner> Tree<Inner>

where Inner: MutableGraph + Deserialize<'de>,

pub fn from_json(json: &'de str) -> Result<Self, Error>

Trait Implementations

impl<Inner> Clone for Tree<Inner>

where Inner: MutableGraph + Clone,

fn clone(&self) -> Tree<Inner>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Inner> Debug for Tree<Inner>

where Inner: MutableGraph + Debug,

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

Formats the value using the given formatter.

impl<Inner> Default for Tree<Inner>

where Inner: MutableGraph + Default + Clone, Inner::NData: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Inner> Deserialize<'de> for Tree<Inner>

where Inner: MutableGraph + Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Inner> Display for Tree<Inner>

where Inner: MutableGraph + Serialize,

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

Formats the value using the given formatter.

impl<Inner> MutableForest for Tree<Inner>

where Inner: MutableGraph,

fn add_node_with_node_and_edge_data( &mut self, node: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, node_data: Self::NData, edge_data: Self::EData, ) -> Result<()>

fn remove_node_ungrouping(&mut self, id: impl AsRef<NodeID>) -> Result<()>

fn remove_node_and_children(&mut self, id: impl AsRef<NodeID>) -> Result<Nodes>

fn remove_children(&mut self, id: impl AsRef<NodeID>) -> Result<Nodes>

fn move_node( &mut self, id: impl AsRef<NodeID>, new_parent: Option<impl AsRef<NodeID>>, ) -> Result<()>

fn set_data(&mut self, data: Self::GData)

fn set_node_data( &mut self, id: impl AsRef<NodeID>, data: Self::NData, ) -> Result<()>

fn set_edge_data( &mut self, id: impl AsRef<EdgeID>, data: Self::EData, ) -> Result<()>

fn with_data(&mut self, transform: &dyn Fn(&mut Self::GData))

fn with_node_data( &mut self, id: impl AsRef<NodeID>, transform: &dyn Fn(&mut Self::NData), ) -> Result<()>

fn with_edge_data( &mut self, id: impl AsRef<EdgeID>, transform: &dyn Fn(&mut Self::EData), ) -> Result<()>

fn adding_node_with_node_and_edge_data( &self, node: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, node_data: Self::NData, edge_data: Self::EData, ) -> Result<Self>

where Self: Clone + Sized,

fn removing_node_ungrouping(&self, id: impl AsRef<NodeID>) -> Result<Self>

where Self: Clone + Sized,

fn removing_node_and_children(&self, id: impl AsRef<NodeID>) -> Result<Self>

where Self: Clone + Sized,

fn removing_children(&self, id: impl AsRef<NodeID>) -> Result<Self>

where Self: Clone + Sized,

fn moving_node( &self, id: impl AsRef<NodeID>, new_parent: Option<impl AsRef<NodeID>>, ) -> Result<Self>

where Self: Clone + Sized,

fn setting_data(&self, data: Self::GData) -> Self

where Self: Clone + Sized,

fn setting_node_data( &self, id: impl AsRef<NodeID>, data: Self::NData, ) -> Result<Self>

where Self: Clone + Sized,

fn setting_edge_data( &self, id: impl AsRef<EdgeID>, data: Self::EData, ) -> Result<Self>

where Self: Clone + Sized,

fn add_node( &mut self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, ) -> Result<()>

where Self::NData: Default, Self::EData: Default,

fn adding_node( &self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, ) -> Result<Self>

where Self: Clone + Sized, Self::NData: Default, Self::EData: Default,

fn add_node_with_edge_data( &mut self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, edge_data: Self::EData, ) -> Result<()>

where Self::NData: Default,

fn adding_node_with_edge_data( &self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, edge_data: Self::EData, ) -> Result<Self>

where Self: Clone + Sized, Self::NData: Default,

fn add_node_with_node_data( &mut self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, node_data: Self::NData, ) -> Result<()>

where Self::EData: Default,

fn adding_node_with_node_data( &self, id: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, node_data: Self::NData, ) -> Result<Self>

where Self: Clone + Sized, Self::EData: Default,

impl<Inner> MutableTree for Tree<Inner>

where Inner: MutableGraph,

fn set_root(&mut self, root: impl AsRef<NodeID>) -> Result<()>

fn setting_root(&self, root: impl AsRef<NodeID>) -> Result<Self>

where Self: Clone + Sized,

impl<Inner> PartialEq for Tree<Inner>

where Inner: MutableGraph + PartialEq,

fn eq(&self, other: &Self) -> 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<Inner> Serialize for Tree<Inner>

where Inner: MutableGraph + Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Inner> VisitableForest for Tree<Inner>

where Inner: MutableGraph,

fn in_edge(&self, node: impl AsRef<NodeID>) -> Result<Option<EdgeID>>

fn in_edge_with_root(&self, node: impl AsRef<NodeID>) -> Result<Option<EdgeID>>

fn parent(&self, node: impl AsRef<NodeID>) -> Result<Option<NodeID>>

fn children(&self, node: Option<impl AsRef<NodeID>>) -> Result<Nodes>

fn has_children(&self, node: impl AsRef<NodeID>) -> Result<bool>

fn child_count(&self, node: impl AsRef<NodeID>) -> Result<usize>

fn descendants(&self, nodes: &Nodes) -> Result<Nodes>

fn ancestors(&self, nodes: &Nodes) -> Result<Nodes>

impl<Inner> VisitableGraph for Tree<Inner>

where Inner: MutableGraph,

type GData = <Inner as VisitableGraph>::GData

type NData = <Inner as VisitableGraph>::NData

type EData = <Inner as VisitableGraph>::EData

fn data(&self) -> &Self::GData

Returns a reference to the graph’s data.

fn node_data(&self, id: impl AsRef<NodeID>) -> Result<Cow<'static, Self::NData>>

Returns a reference to the node’s data.

fn edge_data(&self, id: impl AsRef<EdgeID>) -> Result<Cow<'static, Self::EData>>

Returns a reference to the edge’s data.

fn is_empty(&self) -> bool

Returns true if the graph is empty.

fn node_count(&self) -> usize

Returns the number of nodes in the graph.

fn edge_count(&self) -> usize

Returns the number of edges in the graph.

fn all_nodes(&self) -> Nodes

Returns a set of all nodes in the graph.

fn all_edges(&self) -> Edges

Returns a set of all edges in the graph.

fn has_node(&self, id: impl AsRef<NodeID>) -> bool

Returns true if the graph contains the given node.

fn has_edge(&self, id: impl AsRef<EdgeID>) -> bool

Returns true if the graph contains the given edge.

fn has_edge_from_to( &self, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, ) -> bool

Returns true if the graph contains an edge from source to target.

fn has_edge_between(&self, a: impl AsRef<NodeID>, b: impl AsRef<NodeID>) -> bool

Returns true if the graph contains an edge between a and b, regardless of direction.

fn source(&self, id: impl AsRef<EdgeID>) -> Result<NodeID>

Returns the source node of the edge.

fn target(&self, id: impl AsRef<EdgeID>) -> Result<NodeID>

Returns the target node of the edge.

fn endpoints(&self, id: impl AsRef<EdgeID>) -> Result<(NodeID, NodeID)>

Returns the endpoints of the edge.

fn out_edges(&self, id: impl AsRef<NodeID>) -> Result<Edges>

Returns the out-edges of the node.

fn in_edges(&self, id: impl AsRef<NodeID>) -> Result<Edges>

Returns the in-edges of the node.

fn incident_edges(&self, id: impl AsRef<NodeID>) -> Result<Edges>

Returns the incident edges of the node.

fn out_degree(&self, id: impl AsRef<NodeID>) -> Result<usize>

Returns the number of out-edges of the node.

fn in_degree(&self, id: impl AsRef<NodeID>) -> Result<usize>

Returns the number of in-edges of the node.

fn degree(&self, id: impl AsRef<NodeID>) -> Result<usize>

Returns the number of incident edges of the node.

fn successors(&self, id: impl AsRef<NodeID>) -> Result<Nodes>

Returns the immediate successors of the node.

fn predecessors(&self, id: impl AsRef<NodeID>) -> Result<Nodes>

Returns the immediate predecessors of the node.

fn neighbors(&self, id: impl AsRef<NodeID>) -> Result<Nodes>

Returns the immediate neighbors of the node.

fn has_successors(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node has successors.

fn has_predecessors(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node has predecessors.

fn has_neighbors(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node has neighbors.

fn all_roots(&self) -> Nodes

The set of all “roots” (nodes with no predecessors) in the graph.

fn all_leaves(&self) -> Nodes

The set of all “leaves” (nodes with no successors) in the graph.

fn non_roots(&self) -> Nodes

The set of all nodes that are not roots (i.e., nodes with at least one predecessor).

fn non_leaves(&self) -> Nodes

The set of all nodes that are not leaves (i.e., nodes with at least one successor).

fn all_internals(&self) -> Nodes

The set of all nodes that are neither roots nor leaves (i.e., nodes with at least one predecessor and at least one successor).

fn is_leaf(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node is a leaf (i.e., has no successors).

fn is_root(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node is a root (i.e., has no predecessors).

fn is_internal(&self, id: impl AsRef<NodeID>) -> Result<bool>

Returns true if the node is neither a root nor a leaf (i.e., has at least one predecessor and at least one successor).

fn elements(&self) -> Elements

Returns the set of all elements in the graph.

fn edges_from_to( &self, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, ) -> Result<Edges>

Returns the edges that have the given source and target nodes.

fn edges_between( &self, a: impl AsRef<NodeID>, b: impl AsRef<NodeID>, ) -> Result<Edges>

Returns the edges that have the given nodes as endpoints.

fn edges_from_to_nodes(&self, sources: &Nodes, targets: &Nodes) -> Result<Edges>

Returns the edges connecting the given source nodes to the given target nodes.

fn edges_between_nodes(&self, a: &Nodes, b: &Nodes) -> Result<Edges>

Returns the edges connecting the given sets of nodes.

fn nodes_successors(&self, ids: &Nodes) -> Result<Nodes>

Returns the immediate successors of all the given nodes.

fn nodes_predecessors(&self, ids: &Nodes) -> Result<Nodes>

Returns the immediate predecessors of all the given nodes.

fn transitive_successors(&self, ids: &Nodes) -> Result<Nodes>

Returns the transitive successors of all the given nodes (i.e., all the nodes reachable from the out-edges of the given nodes).

fn transitive_predecessors(&self, ids: &Nodes) -> Result<Nodes>

Returns the transitive predecessors of all the given nodes (i.e., all the nodes reachable from the in-edges of the given nodes).

impl<Inner> VisitableTree for Tree<Inner>

where Inner: MutableGraph,

fn root(&self) -> NodeID

impl<Inner> Eq for Tree<Inner>

where Inner: MutableGraph + Eq,