Trait ratio_graph::edge::EdgeStore

pub trait EdgeStore: HasEdgeStore {
    // Provided methods
    fn edges_len(&self) -> usize { ... }
    fn is_edges_empty(&self) -> bool { ... }
    fn add_edge<N: NodeStore>(
        &mut self,
        edge: Edge,
        safe: bool,
        nodes: Option<&N>
    ) -> Result<Option<Edge>> { ... }
    fn extend_edges<N: NodeStore>(
        &mut self,
        edges: Vec<Edge>,
        safe: bool,
        nodes: Option<&N>
    ) -> Result<Vec<Edge>> { ... }
    fn check_edge<N: NodeStore>(&self, edge: &Edge, nodes: &N) -> Result<()> { ... }
    fn del_edge(&mut self, id: &Uuid) -> Option<Edge> { ... }
    fn get_edge(&self, id: &Uuid) -> Option<&Edge> { ... }
    fn all_edges(&self) -> Vec<&Edge> { ... }
    fn edge_ids_between(&self, source: &Uuid, target: &Uuid) -> HashSet<Uuid> { ... }
    fn edges_between(&self, source: &Uuid, target: &Uuid) -> Vec<&Edge> { ... }
    fn edge_ids_between_all(
        &self,
        sources: &HashSet<Uuid>,
        targets: &HashSet<Uuid>
    ) -> HashSet<Uuid> { ... }
    fn edges_between_all(
        &self,
        sources: &HashSet<Uuid>,
        targets: &HashSet<Uuid>
    ) -> Vec<&Edge> { ... }
    fn aggregate_between(
        &self,
        source: &Uuid,
        target: &Uuid,
        filter: Option<&MetadataFilter>
    ) -> Aggregate { ... }
    fn aggregate_between_all(
        &self,
        sources: &HashSet<Uuid>,
        targets: &HashSet<Uuid>,
        filter: Option<&MetadataFilter>
    ) -> Aggregate { ... }
    fn aggregate_value_between(
        &self,
        source: &Uuid,
        target: &Uuid,
        aggregator: &Aggregator,
        filter: Option<&MetadataFilter>,
        fields: Option<&HashSet<String>>
    ) -> f64 { ... }
    fn aggregate_map_between_all(
        &self,
        sources: &HashSet<Uuid>,
        targets: &HashSet<Uuid>,
        filter: Option<&MetadataFilter>
    ) -> HashMap<Uuid, HashMap<Uuid, Aggregate>> { ... }
    fn outgoing_ids_from(&self, source: &Uuid) -> HashSet<Uuid> { ... }
    fn outgoing_edges_from(&self, source: &Uuid) -> Vec<&Edge> { ... }
    fn incoming_ids_to(&self, target: &Uuid) -> HashSet<Uuid> { ... }
    fn incoming_edges_to(&self, target: &Uuid) -> Vec<&Edge> { ... }
    fn targets_of(&self, source: &Uuid) -> HashSet<Uuid> { ... }
    fn sources_to(&self, target: &Uuid) -> HashSet<Uuid> { ... }
    fn is_connected_to(
        &self,
        node: &Uuid,
        others: &HashSet<Uuid>,
        edge_ids: Option<&HashSet<Uuid>>
    ) -> bool { ... }
    fn adjacency_matrix(
        &self,
        sources: &Vec<&Uuid>,
        targets: &Vec<&Uuid>,
        aggregator: &Aggregator,
        filter: Option<&MetadataFilter>,
        fields: Option<&HashSet<String>>
    ) -> DMatrix<f64> { ... }
    fn edge_aggregate(&self) -> &Aggregate { ... }
}

Provided Methods

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

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

Add multiple edges to this store at once.

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

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) -> Vec<&Edge>

Get all edges in store.

fn edge_ids_between(&self, source: &Uuid, target: &Uuid) -> HashSet<Uuid>

Get all edge IDs between a given source and target node.

fn edges_between(&self, source: &Uuid, target: &Uuid) -> Vec<&Edge>

Get all edges between a given source and target node.

fn edge_ids_between_all( &self, sources: &HashSet<Uuid>, targets: &HashSet<Uuid> ) -> HashSet<Uuid>

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

fn edges_between_all( &self, sources: &HashSet<Uuid>, targets: &HashSet<Uuid> ) -> Vec<&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: &HashSet<Uuid>, targets: &HashSet<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<&HashSet<String>> ) -> f64

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

fn aggregate_map_between_all( &self, sources: &HashSet<Uuid>, targets: &HashSet<Uuid>, filter: Option<&MetadataFilter> ) -> HashMap<Uuid, HashMap<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 outgoing_ids_from(&self, source: &Uuid) -> HashSet<Uuid>

Get all outgoing edge IDs originating from this source node.

fn outgoing_edges_from(&self, source: &Uuid) -> Vec<&Edge>

Get all outgoing edges originating from this source node.

fn incoming_ids_to(&self, target: &Uuid) -> HashSet<Uuid>

Get all incoming edge IDs towards this target node.

fn incoming_edges_to(&self, target: &Uuid) -> Vec<&Edge>

Get all incoming edges towards this target node.

fn targets_of(&self, source: &Uuid) -> HashSet<Uuid>

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

fn sources_to(&self, target: &Uuid) -> HashSet<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: &HashSet<Uuid>, edge_ids: Option<&HashSet<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<&HashSet<String>> ) -> 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.

Implementors

impl EdgeStore for Graph

impl EdgeStore for EdgeStoreData