Struct Graph 

pub struct Graph<GData, NData, EData>
where
    GData: Clone + 'static,
    NData: Clone + 'static,
    EData: Clone + 'static,
{ /* private fields */ }

A general graph data structure with value semantics.

The graph is parameterized by three types:

• GData is the type of the graph data.
• NData is the type of the node data.
• EData is the type of the edge data.

The graph is implemented as a set of nodes and edges. Nodes are identified by unique NodeID values, and edges are identified by unique EdgeID values. The graph and its nodes and edges can have associated data, or they can be the unit type ().

Implementations

impl<GData, NData, EData> Graph<GData, NData, EData>

where GData: Clone + 'static, NData: Clone + 'static, EData: Clone + 'static,

pub fn new_with_data(data: GData) -> Self

impl<GData, NData, EData> Graph<GData, NData, EData>

where GData: Clone + Default + 'static, NData: Clone + 'static, EData: Clone + 'static,

pub fn new() -> Self

impl<GData, NData, EData> Graph<GData, NData, EData>

where GData: Clone + Serialize + 'static, NData: Clone + Serialize + 'static, EData: Clone + Serialize + 'static,

pub fn to_json(&self) -> String

impl<'de, GData, NData, EData> Graph<GData, NData, EData>

where GData: Clone + Default + Deserialize<'de> + 'static, NData: Clone + Default + Deserialize<'de> + 'static, EData: Clone + Default + Deserialize<'de> + 'static,

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

Trait Implementations

impl<GData, NData, EData> Clone for Graph<GData, NData, EData>

where GData: Clone + 'static + Clone, NData: Clone + 'static + Clone, EData: Clone + 'static + Clone,

fn clone(&self) -> Graph<GData, NData, EData>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<GData, NData, EData> Debug for Graph<GData, NData, EData>

where GData: Clone + 'static + Debug, NData: Clone + 'static + Debug, EData: Clone + 'static + Debug,

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

Formats the value using the given formatter.

impl<GData, NData, EData> Default for Graph<GData, NData, EData>

where GData: Clone + Default + 'static, NData: Clone + 'static, EData: Clone + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, GData, NData, EData> Deserialize<'de> for Graph<GData, NData, EData>

where GData: Clone + Deserialize<'de> + 'static + Default, NData: Clone + Deserialize<'de> + 'static + Default, EData: Clone + Deserialize<'de> + 'static + Default,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<GData, NData, EData> Display for Graph<GData, NData, EData>

where GData: Clone + Serialize + 'static, NData: Clone + Serialize + 'static, EData: Clone + Serialize + 'static,

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

Formats the value using the given formatter.

impl<GData, NData, EData> MutableGraph for Graph<GData, NData, EData>

where GData: Clone + 'static, NData: Clone + 'static, EData: Clone + 'static,

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

fn add_edge_with_data( &mut self, id: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, data: Self::EData, ) -> Result<()>

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

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

fn remove_node(&mut self, id: 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: GData)

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

fn set_edge_data(&mut self, id: impl AsRef<EdgeID>, data: 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_data( &self, id: impl AsRef<NodeID>, data: Self::NData, ) -> Result<Self>

where Self: Clone + Sized,

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

where Self::NData: Default,

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

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

fn adding_edge_with_data( &self, id: impl AsRef<EdgeID>, source: impl AsRef<NodeID>, target: impl AsRef<NodeID>, data: Self::EData, ) -> Result<Self>

where Self: Clone + Sized,

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

where Self::EData: Default,

fn adding_edge( &self, id: 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 removing_node(&self, id: impl AsRef<NodeID>) -> Result<Self>

where Self: Clone + Sized,

fn moving_edge( &self, id: impl AsRef<EdgeID>, new_source: impl AsRef<NodeID>, new_target: 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<GData, NData, EData> PartialEq for Graph<GData, NData, EData>

where GData: Clone + PartialEq + 'static, NData: Clone + PartialEq + 'static, EData: Clone + PartialEq + 'static,

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<GData, NData, EData> Serialize for Graph<GData, NData, EData>

where GData: Clone + Serialize + 'static, NData: Clone + Serialize + 'static, EData: Clone + Serialize + 'static,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<GData, NData, EData> VisitableGraph for Graph<GData, NData, EData>

where GData: Clone + 'static, NData: Clone + 'static, EData: Clone + 'static,

type GData = GData

type NData = NData

type EData = EData

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 data(&self) -> &GData

Returns a reference to the graph’s data.

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

Returns a reference to the node’s data.

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

Returns a reference to the edge’s data.

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).