Struct CompoundBase 

pub struct CompoundBase<InnerGraph, InnerForest>
where
    InnerGraph: MutableGraph,
    InnerForest: MutableForest<GData = (), NData = (), EData = ()>,
{ /* private fields */ }

A compound graph is a graph with a parallel forest that puts the nodes of the graph into a hierarchy.

The sets of edges of the graph and the forest are disjoint. The set of nodes between the graph and the tree are identical.

Implementations

impl<InnerGraph, InnerForest> CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Default,

pub fn new_with_graph_and_forest( graph: InnerGraph, forest: InnerForest, ) -> Result<Self>

pub fn new_with_graph(graph: InnerGraph) -> Result<Self>

impl<InnerGraph, InnerForest> CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Default, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Default,

pub fn new() -> Self

pub fn new_with_forest(forest: InnerForest) -> Result<Self>

pub fn graph(&self) -> &InnerGraph

pub fn forest(&self) -> &InnerForest

impl<InnerGraph, InnerForest> CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Serialize, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Serialize,

pub fn to_json(&self) -> String

impl<'de, InnerGraph, InnerForest> CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Deserialize<'de>, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Deserialize<'de> + Default,

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

Trait Implementations

impl<InnerGraph, InnerForest> Clone for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Clone, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Clone,

fn clone(&self) -> CompoundBase<InnerGraph, InnerForest>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<InnerGraph, InnerForest> Debug for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Debug, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Debug,

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

Formats the value using the given formatter.

impl<InnerGraph, InnerForest> Default for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Default, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, InnerGraph, InnerForest> Deserialize<'de> for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Deserialize<'de>, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Deserialize<'de> + Default,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<InnerGraph, InnerForest> Display for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Serialize, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Serialize,

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

Formats the value using the given formatter.

impl<InnerGraph, InnerForest> MutableCompound for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()>,

fn add_node_with_data( &mut self, node: impl AsRef<NodeID>, parent: Option<impl AsRef<NodeID>>, edge: impl AsRef<EdgeID>, node_data: InnerGraph::NData, ) -> 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 add_edge_with_data( &mut self, edge: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, edge_data: InnerGraph::EData, ) -> Result<()>

fn remove_edge(&mut self, id: impl AsRef<EdgeID>) -> Result<()>

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

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

fn move_edge( &mut self, id: impl AsRef<EdgeID>, new_source: impl AsRef<NodeID>, new_target: impl AsRef<NodeID>, ) -> Result<()>

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

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

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

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

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

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

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

where Self: Clone + Sized,

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

where Self::NData: Default,

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

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

fn moving_node( &self, id: impl AsRef<NodeID>, new_parent: Option<impl AsRef<NodeID>>, ) -> 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 adding_edge_with_data( &self, edge: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, edge_data: Self::EData, ) -> Result<Self>

where Self: Clone + Sized,

fn add_edge( &mut self, edge: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, ) -> Result<()>

where Self::EData: Default,

fn adding_edge( &self, edge: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, ) -> Result<Self>

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

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

where Self: Clone + Sized,

fn clearing_edges(&self, id: 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,

impl<InnerGraph, InnerForest> PartialEq for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + PartialEq, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + PartialEq,

fn eq(&self, other: &CompoundBase<InnerGraph, InnerForest>) -> 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<InnerGraph, InnerForest> Serialize for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Serialize, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<InnerGraph, InnerForest> VisitableForest for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()>,

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<InnerGraph, InnerForest> VisitableGraph for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()>,

type GData = <InnerGraph as VisitableGraph>::GData

type NData = <InnerGraph as VisitableGraph>::NData

type EData = <InnerGraph 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<InnerGraph, InnerForest> Eq for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph + Eq, InnerForest: MutableForest<GData = (), NData = (), EData = ()> + Eq,

impl<InnerGraph, InnerForest> StructuralPartialEq for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()>,

impl<InnerGraph, InnerForest> VisitableCompound for CompoundBase<InnerGraph, InnerForest>

where InnerGraph: MutableGraph, InnerForest: MutableForest<GData = (), NData = (), EData = ()>,