raphtory 0.17.0

use crate::db::api::view::internal::{
    time_semantics::{
        base_time_semantics::BaseTimeSemantics, event_semantics::EventSemantics,
        persistent_semantics::PersistentSemantics, time_semantics_ops::NodeTimeSemanticsOps,
        window_time_semantics::WindowTimeSemantics,
    },
    EdgeTimeSemanticsOps, GraphView,
};
use iter_enum::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
use raphtory_api::core::{
    entities::{properties::prop::Prop, LayerIds, ELID},
    storage::timeindex::EventTime,
};
use raphtory_storage::graph::{edges::edge_ref::EdgeStorageRef, nodes::node_ref::NodeStorageRef};
use std::ops::Range;

#[derive(Clone, Debug)]
pub enum TimeSemantics {
    Base(BaseTimeSemantics),
    Window(WindowTimeSemantics),
}

macro_rules! for_all {
    ($value:expr, $pattern:pat => $result:expr) => {
        match $value {
            TimeSemantics::Base($pattern) => $result,
            TimeSemantics::Window($pattern) => $result,
        }
    };
}

#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, FusedIterator)]
pub enum TimeSemanticsVariants<Base, Window> {
    Base(Base),
    Window(Window),
}

macro_rules! for_all_iter {
    ($value:expr, $pattern:pat => $result:expr) => {
        match $value {
            TimeSemantics::Base($pattern) => TimeSemanticsVariants::Base($result),
            TimeSemantics::Window($pattern) => TimeSemanticsVariants::Window($result),
        }
    };
}

impl NodeTimeSemanticsOps for TimeSemantics {
    fn node_earliest_time<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.node_earliest_time(node, view))
    }

    fn node_latest_time<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.node_latest_time(node, view))
    }

    fn node_earliest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.node_earliest_time_window(node, view, w))
    }

    fn node_latest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.node_latest_time_window(node, view, w))
    }

    fn node_history<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_history(node, view))
    }

    fn node_history_rev<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_history_rev(node, view))
    }

    fn node_history_window<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_history_window(node, view, w))
    }

    fn node_history_window_rev<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = EventTime> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_history_window_rev(node, view, w))
    }

    fn node_valid_window<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.node_valid_window(node, view, w))
    }

    fn node_updates<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_updates(node, view))
    }

    fn node_updates_window<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, Vec<(usize, Prop)>)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_updates_window(node, view, w))
    }

    fn node_valid<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> bool {
        for_all!(self, semantics => semantics.node_valid(node, view))
    }

    fn node_tprop_iter<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        prop_id: usize,
    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_tprop_iter(node, view, prop_id))
    }

    fn node_tprop_iter_window<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        w: Range<EventTime>,
    ) -> impl DoubleEndedIterator<Item = (EventTime, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_tprop_iter_window(node, view, prop_id, w))
    }

    fn node_tprop_last_at<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        t: EventTime,
    ) -> Option<(EventTime, Prop)> {
        for_all!(self, semantics => semantics.node_tprop_last_at(node, view, prop_id, t))
    }

    fn node_tprop_last_at_window<'graph, G: GraphView + 'graph>(
        &self,
        node: NodeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        t: EventTime,
        w: Range<EventTime>,
    ) -> Option<(EventTime, Prop)> {
        for_all!(self, semantics => semantics.node_tprop_last_at_window(node, view, prop_id, t, w))
    }

    fn node_edge_history_count<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> usize {
        for_all!(self, semantics => semantics.node_edge_history_count(node, view))
    }

    fn node_edge_history_count_window<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> usize {
        for_all!(self, semantics => semantics.node_edge_history_count_window(node, view, w))
    }

    fn node_edge_history<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_edge_history(node, view))
    }

    fn node_edge_history_window<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_edge_history_window(node, view, w))
    }

    fn node_edge_history_rev<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
    ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_edge_history_rev(node, view))
    }

    fn node_edge_history_rev_window<'graph, G: GraphView + 'graph>(
        self,
        node: NodeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, ELID)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.node_edge_history_rev_window(node, view, w))
    }
}

impl EdgeTimeSemanticsOps for TimeSemantics {
    fn handle_edge_update_filter<G: GraphView>(
        &self,
        t: EventTime,
        eid: ELID,
        view: G,
    ) -> Option<(EventTime, ELID)> {
        for_all!(self, semantics => semantics.handle_edge_update_filter(t, eid, view))
    }

    fn include_edge<G: GraphView>(&self, edge: EdgeStorageRef, view: G, layer_id: usize) -> bool {
        for_all!(self, semantics => semantics.include_edge(edge, view, layer_id))
    }

    fn include_edge_window<G: GraphView>(
        &self,
        edge: EdgeStorageRef,
        view: G,
        layer_id: usize,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.include_edge_window(edge, view, layer_id, w))
    }

    fn include_exploded_edge<G: GraphView>(&self, elid: ELID, t: EventTime, view: G) -> bool {
        for_all!(self, semantics => semantics.include_exploded_edge(elid, t, view))
    }

    fn include_exploded_edge_window<G: GraphView>(
        &self,
        elid: ELID,
        t: EventTime,
        view: G,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.include_exploded_edge_window(elid, t, view, w))
    }

    fn edge_history<'graph, G: GraphView + 'graph>(
        self,
        edge: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_history(edge, view, layer_ids))
    }

    fn edge_history_rev<'graph, G: GraphView + 'graph>(
        self,
        edge: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_history_rev(edge, view, layer_ids))
    }

    fn edge_history_window<'graph, G: GraphView + 'graph>(
        self,
        edge: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_history_window(edge, view, layer_ids, w))
    }

    fn edge_history_window_rev<'graph, G: GraphView + 'graph>(
        self,
        edge: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_history_window_rev(edge, view, layer_ids, w))
    }

    fn edge_exploded_count<'graph, G: GraphView + 'graph>(
        &self,
        edge: EdgeStorageRef,
        view: G,
    ) -> usize {
        for_all!(self, semantics => semantics.edge_exploded_count(edge, view))
    }

    fn edge_exploded_count_window<'graph, G: GraphView + 'graph>(
        &self,
        edge: EdgeStorageRef,
        view: G,
        w: Range<EventTime>,
    ) -> usize {
        for_all!(self, semantics => semantics.edge_exploded_count_window(edge, view, w))
    }

    fn edge_exploded<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_exploded(e, view, layer_ids))
    }

    fn edge_layers<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_layers(e, view, layer_ids))
    }

    fn edge_window_exploded<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_window_exploded(e, view, layer_ids, w))
    }

    fn edge_window_layers<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = usize> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_window_layers(e, view, layer_ids, w))
    }

    fn edge_earliest_time<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_earliest_time(e, view))
    }

    fn edge_earliest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_earliest_time_window(e, view, w))
    }

    fn edge_exploded_earliest_time<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        t: EventTime,
        layer: usize,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_earliest_time(e, view, t, layer))
    }

    fn edge_exploded_earliest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        t: EventTime,
        layer: usize,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_earliest_time_window(e, view, t, layer, w))
    }

    fn edge_latest_time<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_latest_time(e, view))
    }

    fn edge_latest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_latest_time_window(e, view, w))
    }

    fn edge_exploded_latest_time<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        t: EventTime,
        layer: usize,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_latest_time(e, view, t, layer))
    }

    fn edge_exploded_latest_time_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef,
        view: G,
        t: EventTime,
        layer: usize,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_latest_time_window(e, view, t, layer, w))
    }

    fn edge_deletion_history<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_deletion_history(e, view, layer_ids))
    }

    fn edge_deletion_history_rev<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_deletion_history_rev(e, view, layer_ids))
    }

    fn edge_deletion_history_window<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_deletion_history_window(e, view, layer_ids, w))
    }

    fn edge_deletion_history_window_rev<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.edge_deletion_history_window_rev(e, view, layer_ids, w))
    }

    fn edge_is_valid<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_valid(e, view))
    }

    fn edge_is_valid_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        r: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_valid_window(e, view, r))
    }

    fn edge_is_deleted<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_deleted(e, view))
    }

    fn edge_is_deleted_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_deleted_window(e, view, w))
    }

    fn edge_is_active<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_active(e, view))
    }

    fn edge_is_active_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_active_window(e, view, w))
    }

    fn edge_is_active_exploded<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_active_exploded(e, view, t, layer))
    }

    fn edge_is_active_exploded_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_active_exploded_window(e, view, t, layer, w))
    }

    fn edge_is_valid_exploded<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_valid_exploded(e, view, t, layer))
    }

    fn edge_is_valid_exploded_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
        w: Range<EventTime>,
    ) -> bool {
        for_all!(self, semantics => semantics.edge_is_valid_exploded_window(e, view, t, layer, w))
    }

    fn edge_exploded_deletion<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_deletion(e, view, t, layer))
    }

    fn edge_exploded_deletion_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        t: EventTime,
        layer: usize,
        w: Range<EventTime>,
    ) -> Option<EventTime> {
        for_all!(self, semantics => semantics.edge_exploded_deletion_window(e, view, t, layer, w))
    }

    fn temporal_edge_prop_exploded<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        t: EventTime,
        layer_id: usize,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.temporal_edge_prop_exploded(e, view, prop_id, t, layer_id))
    }

    fn temporal_edge_prop_exploded_last_at<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        edge_time: EventTime,
        layer_id: usize,
        prop_id: usize,
        at: EventTime,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.temporal_edge_prop_exploded_last_at(e, view, edge_time, layer_id, prop_id, at))
    }

    fn temporal_edge_prop_exploded_last_at_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        edge_time: EventTime,
        layer_id: usize,
        prop_id: usize,
        at: EventTime,
        w: Range<EventTime>,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.temporal_edge_prop_exploded_last_at_window(e, view, edge_time, layer_id, prop_id, at, w))
    }

    fn temporal_edge_prop_last_at<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        t: EventTime,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.temporal_edge_prop_last_at(e, view, prop_id, t))
    }

    fn temporal_edge_prop_last_at_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        t: EventTime,
        w: Range<EventTime>,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.temporal_edge_prop_last_at_window(e, view, prop_id, t, w))
    }

    fn temporal_edge_prop_hist<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        prop_id: usize,
    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist(e, view, layer_ids, prop_id))
    }

    fn temporal_edge_prop_hist_rev<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        prop_id: usize,
    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_rev(e, view, layer_ids, prop_id))
    }

    fn temporal_edge_prop_hist_window<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        prop_id: usize,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window(e, view, layer_ids, prop_id, w))
    }

    fn temporal_edge_prop_hist_window_rev<'graph, G: GraphView + 'graph>(
        self,
        e: EdgeStorageRef<'graph>,
        view: G,
        layer_ids: &'graph LayerIds,
        prop_id: usize,
        w: Range<EventTime>,
    ) -> impl Iterator<Item = (EventTime, usize, Prop)> + Send + Sync + 'graph {
        for_all_iter!(self, semantics => semantics.temporal_edge_prop_hist_window_rev(e, view, layer_ids, prop_id, w))
    }

    /// Get edge metadata
    ///
    /// Returns:
    ///     PropValue:
    fn edge_metadata<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        prop_id: usize,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.edge_metadata(e, view, prop_id))
    }

    fn edge_metadata_window<'graph, G: GraphView + 'graph>(
        &self,
        e: EdgeStorageRef<'graph>,
        view: G,
        prop_id: usize,
        w: Range<EventTime>,
    ) -> Option<Prop> {
        for_all!(self, semantics => semantics.edge_metadata_window(e, view, prop_id, w))
    }
}

impl TimeSemantics {
    pub fn persistent() -> Self {
        TimeSemantics::Base(BaseTimeSemantics::Persistent(PersistentSemantics))
    }

    pub fn event() -> Self {
        TimeSemantics::Base(BaseTimeSemantics::Event(EventSemantics))
    }

    pub fn window(self, w: Range<EventTime>) -> Self {
        match self {
            TimeSemantics::Base(semantics) => TimeSemantics::Window(WindowTimeSemantics {
                semantics,
                window: w,
            }),
            TimeSemantics::Window(semantics) => TimeSemantics::Window(semantics.window(w)),
        }
    }
}