Trait 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>, EdgeStoreError> { ... }
    fn extend_edges<N: NodeStore>(
        &mut self,
        edges: Vec<Edge>,
        safe: bool,
        nodes: Option<&N>,
    ) -> Result<Vec<Edge>, EdgeStoreError> { ... }
    fn check_edge<N: NodeStore>(
        &self,
        edge: &Edge,
        nodes: &N,
    ) -> Result<(), EdgeStoreError> { ... }
    fn del_edge(&mut self, id: &Uuid) -> Option<Edge> { ... }
    fn get_edge(&self, id: &Uuid) -> Option<&Edge> { ... }
    fn all_edges(&self) -> impl Iterator<Item = &Edge> { ... }
    fn edge_ids_between(
        &self,
        source: &Uuid,
        target: &Uuid,
    ) -> impl Iterator<Item = Uuid> { ... }
    fn edges_between(
        &self,
        source: &Uuid,
        target: &Uuid,
    ) -> impl Iterator<Item = &Edge> { ... }
    fn edge_ids_between_all(
        &self,
        sources: &BTreeSet<Uuid>,
        targets: &BTreeSet<Uuid>,
    ) -> impl Iterator<Item = Uuid> { ... }
    fn edges_between_all(
        &self,
        sources: &BTreeSet<Uuid>,
        targets: &BTreeSet<Uuid>,
    ) -> impl Iterator<Item = &Edge> { ... }
    fn aggregate_between(
        &self,
        source: &Uuid,
        target: &Uuid,
        filter: Option<&MetadataFilter>,
    ) -> Aggregate { ... }
    fn aggregate_between_all(
        &self,
        sources: &BTreeSet<Uuid>,
        targets: &BTreeSet<Uuid>,
        filter: Option<&MetadataFilter>,
    ) -> Aggregate { ... }
    fn aggregate_value_between(
        &self,
        source: &Uuid,
        target: &Uuid,
        aggregator: &Aggregator,
        filter: Option<&MetadataFilter>,
        fields: Option<&BTreeSet<String>>,
        absolute: bool,
    ) -> f64 { ... }
    fn aggregate_map(
        &self,
        sources: &BTreeSet<Uuid>,
        targets: &BTreeSet<Uuid>,
        filter: Option<&MetadataFilter>,
    ) -> BTreeMap<Uuid, BTreeMap<Uuid, Aggregate>> { ... }
    fn aggregate_matrix(
        &self,
        sources: &[&Uuid],
        targets: &[&Uuid],
        filter: Option<&MetadataFilter>,
    ) -> Vec<Vec<Aggregate>> { ... }
    fn outgoing_ids_from(&self, source: &Uuid) -> impl Iterator<Item = Uuid> { ... }
    fn outgoing_edges_from(&self, source: &Uuid) -> impl Iterator<Item = &Edge> { ... }
    fn incoming_ids_to(&self, target: &Uuid) -> impl Iterator<Item = Uuid> { ... }
    fn incoming_edges_to(&self, target: &Uuid) -> impl Iterator<Item = &Edge> { ... }
    fn targets_of(&self, source: &Uuid) -> impl Iterator<Item = Uuid> { ... }
    fn sources_to(&self, target: &Uuid) -> impl Iterator<Item = Uuid> { ... }
    fn is_connected_to(
        &self,
        node: &Uuid,
        others: &BTreeSet<Uuid>,
        edge_ids: Option<&BTreeSet<Uuid>>,
    ) -> bool { ... }
    fn adjacency_matrix(
        &self,
        sources: &Vec<&Uuid>,
        targets: &Vec<&Uuid>,
        aggregator: &Aggregator,
        filter: Option<&MetadataFilter>,
        fields: Option<&BTreeSet<String>>,
        absolute: bool,
    ) -> 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>, 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl EdgeStore for Graph

impl EdgeStore for EdgeStoreData