Struct Graph 

pub struct Graph {
    pub metadata: Metadata,
    pub nodes: NodeStoreData,
    pub edges: EdgeStoreData,
}

A graph containing nodes and edges.

Fields

metadata: Metadata

Instance metadata.

nodes: NodeStoreData

Node store.

edges: EdgeStoreData

Edge store.

Implementations

impl Graph

pub fn new( metadata: Option<Metadata>, nodes: Vec<Node>, edges: Vec<Edge>, ) -> Result<Self, Error>

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Graph

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Graph

where Graph: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EdgeStore for Graph

fn edges_len(&self) -> usize

The number of edges in store.

fn is_edges_empty(&self) -> bool

Whether the edge store is empty.

fn add_edge<N: NodeStore>( &mut self, edge: Edge, safe: bool, nodes: Option<&N>, ) -> Result<Option<Edge>, EdgeStoreError>

Add a single edge to this store.

fn extend_edges<N: NodeStore>( &mut self, edges: Vec<Edge>, safe: bool, nodes: Option<&N>, ) -> Result<Vec<Edge>, EdgeStoreError>

Add multiple edges to this store at once.

fn check_edge<N: NodeStore>( &self, edge: &Edge, nodes: &N, ) -> Result<(), EdgeStoreError>

Check an edge’s source and target reference in a node store.

fn del_edge(&mut self, id: &Uuid) -> Option<Edge>

Delete an edge from the store.

fn get_edge(&self, id: &Uuid) -> Option<&Edge>

Get an edge from the store.

fn all_edges(&self) -> impl Iterator<Item = &Edge>

Get all edges in store.

fn edge_ids_between( &self, source: &Uuid, target: &Uuid, ) -> impl Iterator<Item = Uuid>

Iterator over all edge IDs between a given source and target node.

fn edges_between( &self, source: &Uuid, target: &Uuid, ) -> impl Iterator<Item = &Edge>

Get all edges between a given source and target node.

fn edge_ids_between_all( &self, sources: &BTreeSet<Uuid>, targets: &BTreeSet<Uuid>, ) -> impl Iterator<Item = Uuid>

Get all edge IDs between a given set of source and target nodes.

fn edges_between_all( &self, sources: &BTreeSet<Uuid>, targets: &BTreeSet<Uuid>, ) -> impl Iterator<Item = &Edge>

Get all edges between a given set of source and target nodes.

fn aggregate_between( &self, source: &Uuid, target: &Uuid, filter: Option<&MetadataFilter>, ) -> Aggregate

Get the calculated aggregate of edge metadata between a source and target node with an optional edge filter.

fn aggregate_between_all( &self, sources: &BTreeSet<Uuid>, targets: &BTreeSet<Uuid>, filter: Option<&MetadataFilter>, ) -> Aggregate

Get the calculated aggregate of edge metadata between a set of source and target nodes with an optional edge filter.

fn aggregate_value_between( &self, source: &Uuid, target: &Uuid, aggregator: &Aggregator, filter: Option<&MetadataFilter>, fields: Option<&BTreeSet<String>>, absolute: bool, ) -> f64

Calculate an aggregate value between a source and target node, optional edge filter and optional field filter.

fn aggregate_map( &self, sources: &BTreeSet<Uuid>, targets: &BTreeSet<Uuid>, filter: Option<&MetadataFilter>, ) -> BTreeMap<Uuid, BTreeMap<Uuid, Aggregate>>

Get the aggregate map from source to target to aggregate for a given set of source and target nodes and an optional edge filter.

fn aggregate_matrix( &self, sources: &[&Uuid], targets: &[&Uuid], filter: Option<&MetadataFilter>, ) -> Vec<Vec<Aggregate>>

Get the aggregate matrix where row indices correspond to target nodes and column indices correspond to source nodes as given in their input vectors. It’s optional to specify an edge filter.

fn outgoing_ids_from(&self, source: &Uuid) -> impl Iterator<Item = Uuid>

Get all outgoing edge IDs originating from this source node.

fn outgoing_edges_from(&self, source: &Uuid) -> impl Iterator<Item = &Edge>

Get all outgoing edges originating from this source node.

fn incoming_ids_to(&self, target: &Uuid) -> impl Iterator<Item = Uuid>

Get all incoming edge IDs towards this target node.

fn incoming_edges_to(&self, target: &Uuid) -> impl Iterator<Item = &Edge>

Get all incoming edges towards this target node.

fn targets_of(&self, source: &Uuid) -> impl Iterator<Item = Uuid>

Get all source node IDs that are connected to this target node by an incoming edge.

fn sources_to(&self, target: &Uuid) -> impl Iterator<Item = Uuid>

Get all source node IDs that are connected to this target node by an incoming edge.

fn is_connected_to( &self, node: &Uuid, others: &BTreeSet<Uuid>, edge_ids: Option<&BTreeSet<Uuid>>, ) -> bool

Check whether a node is connected to a set of other nodes. Optionally specify a limited set of edge IDs that are allowed for connections.

fn adjacency_matrix( &self, sources: &Vec<&Uuid>, targets: &Vec<&Uuid>, aggregator: &Aggregator, filter: Option<&MetadataFilter>, fields: Option<&BTreeSet<String>>, absolute: bool, ) -> DMatrix<f64>

Calculate the adjacency matrix given a set of source and target nodes, aggregator, optional edge filter and optional field filter.

fn edge_aggregate(&self) -> &Aggregate

Get the aggregate.

impl From<Graph> for CompactGraph

fn from(value: Graph) -> Self

Converts to this type from the input type.

impl HasEdgeStore for Graph

fn edge_store(&self) -> &EdgeStoreData

Edge store reference.

fn edge_store_mut(&mut self) -> &mut EdgeStoreData

Mutable edge store reference.

impl HasNodeStore for Graph

fn node_store(&self) -> &NodeStoreData

fn node_store_mut(&mut self) -> &mut NodeStoreData

impl Meta for Graph

fn get_meta(&self) -> &Metadata

fn id(&self) -> &Uuid

fn name(&self) -> &str

fn kind(&self) -> &str

fn labels(&self) -> &BTreeSet<String>

fn weights(&self) -> &BTreeMap<String, f64>

fn annotations(&self) -> &BTreeMap<String, Value>

impl NodeStore for Graph

fn nodes_len(&self) -> usize

The number of nodes in this store.

fn max_node_depth(&mut self) -> usize

where Self: Sized,

Maximum node depth or height.

fn is_nodes_empty(&self) -> bool

Whether this node store is empty.

fn has_node(&self, id: &Uuid) -> bool

Check whether this store contains a node with the given node ID.

fn add_node( &mut self, node: Node, safe: bool, ) -> Result<Option<Node>, NodeStoreError>

where Self: Sized,

Add a single node to this store. Setting ‘safe’ checks whether this node’s references exist and detects cyclic hierarchies.

fn extend_nodes( &mut self, nodes: Vec<Node>, safe: bool, ) -> Result<Vec<Node>, NodeStoreError>

where Self: Sized,

Extend this node store with new nodes. Setting ‘safe’ checks whether all node references exist and detects cyclic hierarchies after adding them to the store first.

fn check_node(&self, node: &Node) -> Result<(), NodeStoreError>

where Self: Sized,

Check whether a node’s references exist and it doesn’t partake in cyclic hierarchies.

fn get_node(&self, id: &Uuid) -> Option<&Node>

Get a reference to a node.

fn get_node_err(&self, id: &Uuid) -> Result<&Node, NodeStoreError>

Get a reference to a node as as result.

fn get_node_mut(&mut self, node_id: &Uuid) -> Option<&mut Node>

Get a mutable reference to a node.

fn del_node(&mut self, node_id: &Uuid) -> Option<Node>

Delete node from this store.

fn calculate_node_depth(&self) -> usize

where Self: Sized,

Update max node depth.

fn all_node_ids(&self) -> impl Iterator<Item = Uuid>

Get all node IDs in this store.

fn all_nodes(&self) -> impl Iterator<Item = &Node>

Get all node IDs in this store.

fn root_ids(&self) -> impl Iterator<Item = Uuid>

Get all root node IDs in this store.

fn root_nodes(&self) -> impl Iterator<Item = &Node>

Get all root nodes in this store.

fn leaf_ids(&self) -> impl Iterator<Item = Uuid>

Get all leaf node IDs in this store.

fn leaf_nodes(&self) -> impl Iterator<Item = &Node>

Get all leaf nodes in this store.

fn set_parent( &mut self, child_id: &Uuid, parent_id: Option<&Uuid>, ) -> Result<(), NodeStoreError>

Set a new parent value for the given child ID. Returns an error if the child node does not exist in the store. Setting the parent ID to None removes the parent-child relationship.

fn set_bus( &mut self, node_id: &Uuid, is_bus: bool, ) -> Result<(), NodeStoreError>

Set the is_bus value of a given node ID.

fn bus_ids( &self, parent_id: &Uuid, ) -> Result<impl Iterator<Item = Uuid>, NodeStoreError>

Get the bus node IDs that fall directly under the given parent ID.

fn bus_nodes( &self, parent_id: &Uuid, ) -> Result<impl Iterator<Item = &Node>, NodeStoreError>

Get the bus nodes that fall directly under the given parent ID.

fn ascendant_ids<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_root: bool, root_ids: Option<&'a BTreeSet<Uuid>>, height: Option<usize>, ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>

where Self: Sized,

Get ascendant node IDs of a given node. Setting safe checks for cyclic hierarchies along the way. only_root only includes the final root node. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn ascendant_nodes<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_root: bool, root_ids: Option<&'a BTreeSet<Uuid>>, height: Option<usize>, ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>

where Self: Sized,

Get ascendant nodes of a given node. Setting safe checks for cyclic hierarchies along the way. only_root only includes the final root node. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn node_depth( &self, node_id: &Uuid, safe: bool, root_ids: Option<&BTreeSet<Uuid>>, height: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node depth (i.e. the number of levels that exist above). Setting safe checks for cyclic hierarchies along the way. root_ids are nodes to consider as (additional) root nodes in this query. height determines the maximum height at which the ancestor is considered a root node.

fn descendant_ids<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_leaf: bool, leaf_ids: Option<&'a BTreeSet<Uuid>>, depth: Option<usize>, ) -> impl Iterator<Item = Result<&'n Uuid, NodeStoreError>>

where Self: Sized,

Get the descendant node IDs of a given node. Setting safe checks for cyclic hierarchies. Setting only_leaf only includes only absolute or specified leaf nodes in the result. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth at which nodes are also considered leaf nodes for this search.

fn descendant_nodes<'a, 'n>( &'n self, node_id: &'a Uuid, safe: bool, only_leaf: bool, leaf_ids: Option<&'a BTreeSet<Uuid>>, depth: Option<usize>, ) -> impl Iterator<Item = Result<&'n Node, NodeStoreError>>

where Self: Sized,

Get the descendant nodes of a given node. Setting safe checks for cyclic hierarchies. Setting only_leaf only includes only absolute or specified leaf nodes in the result. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_height( &self, node_id: &Uuid, safe: bool, leaf_ids: Option<&BTreeSet<Uuid>>, depth: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node height (i.e. the number of levels that exist below). Setting safe checks for cyclic hierarchies. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_width( &self, node_id: &Uuid, safe: bool, leaf_ids: Option<&BTreeSet<Uuid>>, depth: Option<usize>, ) -> Result<usize, NodeStoreError>

where Self: Sized,

Node width in terms of (optionally specified) leaf nodes. Setting safe checks for cyclic hierarchies. leaf_ids restricts the search at the given node IDs, disallowing it from going any further. depth specifies the maximum depth with respect to the given node ID to search at.

fn node_aggregate(&self) -> &Aggregate

Get the aggregate.

impl PartialEq for Graph

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryInto<Graph> for CompactGraph

type Error = Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Graph, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Graph