Struct WindowedGraph 

pub struct WindowedGraph<G> {
    pub graph: G,
    pub start: Option<EventTime>,
    pub end: Option<EventTime>,
}

A struct that represents a windowed view of a Graph.

Fields

graph: G

The underlying Graph object.

start: Option<EventTime>

The inclusive start time of the window.

end: Option<EventTime>

The exclusive end time of the window.

Implementations

impl<'graph, G: GraphViewOps<'graph>> WindowedGraph<G>

A windowed graph is a graph that only allows access to nodes and edges within a time window.

This struct is used to represent a graph with a time window. It is constructed by providing a Graph object and a time range that defines the window.

Examples

use raphtory::db::api::view::*;
use raphtory::prelude::*;

let graph = Graph::new();
graph.add_edge(0, 1, 2, NO_PROPS, None).unwrap();
graph.add_edge(1, 2, 3, NO_PROPS, None).unwrap();
let windowed_graph = graph.window(0, 1);

pub fn new(graph: G, start: Option<EventTime>, end: Option<EventTime>) -> Self

Create a new windowed graph

Arguments

• graph - The graph to create the windowed graph from
• start - The inclusive start time of the window.
• end - The exclusive end time of the window.

Returns:

A new windowed graph

Trait Implementations

impl<'graph, G: GraphViewOps<'graph>> Base for WindowedGraph<G>

type Base = G

fn base(&self) -> &Self::Base

impl<G: Clone> Clone for WindowedGraph<G>

fn clone(&self) -> WindowedGraph<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: Debug> Debug for WindowedGraph<G>

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

Formats the value using the given formatter.

impl<'graph, G: GraphViewOps<'graph>> GraphTimeSemanticsOps for WindowedGraph<G>

fn node_time_semantics(&self) -> TimeSemantics

fn edge_time_semantics(&self) -> TimeSemantics

fn view_start(&self) -> Option<EventTime>

Returns the start of the current view or None if unbounded

fn view_end(&self) -> Option<EventTime>

Returns the end of the current view or None if unbounded

fn earliest_time_global(&self) -> Option<i64>

Returns the timestamp for the earliest activity

fn latest_time_global(&self) -> Option<i64>

Returns the timestamp for the latest activity

fn earliest_time_window(&self, start: EventTime, end: EventTime) -> Option<i64>

Returns the timestamp for the earliest activity in the window

fn latest_time_window(&self, start: EventTime, end: EventTime) -> Option<i64>

Returns the timestamp for the latest activity in the window

fn has_temporal_prop(&self, prop_id: usize) -> bool

Check if graph has temporal property with the given id

fn temporal_prop_iter( &self, prop_id: usize, ) -> BoxedLDIter<'_, (EventTime, Prop)>

Returns an Iterator of all temporal values of the graph property with the given id

fn has_temporal_prop_window(&self, prop_id: usize, w: Range<EventTime>) -> bool

Check if graph has temporal property with the given id in the window

fn temporal_prop_iter_window( &self, prop_id: usize, start: EventTime, end: EventTime, ) -> BoxedLDIter<'_, (EventTime, Prop)>

Returns all temporal values of the graph property with the given name that fall within the specified time window.

fn temporal_prop_last_at( &self, prop_id: usize, t: EventTime, ) -> Option<(EventTime, Prop)>

Returns the value and update time for the temporal graph property at or before a given timestamp

fn temporal_prop_last_at_window( &self, prop_id: usize, t: EventTime, w: Range<EventTime>, ) -> Option<(EventTime, Prop)>

impl<G: GraphView> InternalEdgeFilterOps for WindowedGraph<G>

fn internal_edge_filtered(&self) -> bool

If true, the edges from the underlying storage are filtered

fn internal_edge_list_trusted(&self) -> bool

If true, all edges returned by self.edge_list() exist, otherwise it needs further filtering

fn internal_filter_edge( &self, edge: EdgeStorageRef<'_>, layer_ids: &LayerIds, ) -> bool

fn node_filter_includes_edge_filter(&self) -> bool

fn exploded_edge_filter_includes_edge_filter(&self) -> bool

Set this to true if the exploded filter already implements the edge filter to avoid unnecessary checks

fn edge_layer_filter_includes_edge_filter(&self) -> bool

Set this to true if the edge layer filter already implements the edge filter to avoid unnecessary checks

impl<G: GraphView> InternalEdgeLayerFilterOps for WindowedGraph<G>

fn internal_edge_layer_filtered(&self) -> bool

Set to true when filtering, used for optimisations

fn internal_layer_filter_edge_list_trusted(&self) -> bool

If true, all edges removed by this filter have also been removed from the edge list

fn internal_filter_edge_layer( &self, edge: EdgeStorageRef<'_>, layer: usize, ) -> bool

Filter a layer for an edge

fn node_filter_includes_edge_layer_filter(&self) -> bool

fn edge_filter_includes_edge_layer_filter(&self) -> bool

fn exploded_edge_filter_includes_edge_layer_filter(&self) -> bool

impl<G: GraphView> InternalExplodedEdgeFilterOps for WindowedGraph<G>

fn internal_exploded_edge_filtered(&self) -> bool

Set to true when filtering, used for optimisations

fn internal_exploded_filter_edge_list_trusted(&self) -> bool

If true, all edges removed by this filter have also been removed from the edge list

fn internal_filter_exploded_edge( &self, eid: ELID, t: EventTime, layer_ids: &LayerIds, ) -> bool

fn node_filter_includes_exploded_edge_filter(&self) -> bool

fn edge_filter_includes_exploded_edge_filter(&self) -> bool

fn edge_layer_filter_includes_exploded_edge_filter(&self) -> bool

impl<'graph, G: GraphViewOps<'graph>> InternalNodeFilterOps for WindowedGraph<G>

fn internal_nodes_filtered(&self) -> bool

Check if GraphView filters nodes (i.e., there exists nodes in the underlying graph for which filter_node returns false

fn internal_node_list_trusted(&self) -> bool

Check if node list can be trusted. (if false, nodes in self.node_list need further filtering, if true, the result of self.node_list can be trusted, in particular, its len is the number of nodes in the graph).

fn edge_filter_includes_node_filter(&self) -> bool

If true, do not need to check src and dst of the edge separately, even if nodes are filtered (i.e., edge filter already makes sure there are no edges between non-existent nodes) This should be false when implementing NodeFilterOps without overriding the edge filter.

fn edge_layer_filter_includes_node_filter(&self) -> bool

If true, do not need to check src and dst of the edge separately, even if nodes are filtered (i.e., edge filter already makes sure there are no edges between non-existent nodes) This should be false when implementing NodeFilterOps without overriding the edge layer filter.

fn exploded_edge_filter_includes_node_filter(&self) -> bool

If true, do not need to check src and dst of the edge separately, even if nodes are filtered (i.e., edge filter already makes sure there are no edges between non-existent nodes) This should be false when implementing NodeFilterOps without overriding the exploded edge filter.

fn internal_filter_node( &self, node: NodeStorageRef<'_>, layer_ids: &LayerIds, ) -> bool

If true, node is included in the graph

impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertiesOps for WindowedGraph<G>

fn get_temporal_prop_id(&self, name: &str) -> Option<usize>

fn get_temporal_prop_name(&self, id: usize) -> ArcStr

fn temporal_prop_ids(&self) -> BoxedLIter<'_, usize>

fn temporal_prop_keys(&self) -> BoxedLIter<'_, ArcStr>

impl<'graph, G: GraphViewOps<'graph>> InternalTemporalPropertyViewOps for WindowedGraph<G>

fn dtype(&self, id: usize) -> PropType

fn temporal_value(&self, id: usize) -> Option<Prop>

fn temporal_iter(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)>

fn temporal_iter_rev(&self, id: usize) -> BoxedLIter<'_, (EventTime, Prop)>

fn temporal_value_at(&self, id: usize, t: EventTime) -> Option<Prop>

fn temporal_history_iter(&self, id: usize) -> BoxedLIter<'_, EventTime>

fn temporal_history_iter_rev(&self, id: usize) -> BoxedLIter<'_, EventTime>

fn temporal_values_iter(&self, id: usize) -> BoxedLIter<'_, Prop>

fn temporal_values_iter_rev(&self, id: usize) -> BoxedLIter<'_, Prop>

impl<'graph, G: GraphViewOps<'graph>> ListOps for WindowedGraph<G>

fn node_list(&self) -> NodeList

fn edge_list(&self) -> EdgeList

impl<'graph1, 'graph2, G1: GraphViewOps<'graph1>, G2: GraphViewOps<'graph2>> PartialEq<G2> for WindowedGraph<G1>

fn eq(&self, other: &G2) -> 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<G: Copy> Copy for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> Immutable for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> InheritCoreGraphOps for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> InheritLayerOps for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> InheritMaterialize for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> InheritMetadataPropertiesOps for WindowedGraph<G>

impl<'graph, G: GraphViewOps<'graph>> InheritStorageOps for WindowedGraph<G>

impl<G> Static for WindowedGraph<G>