work on extent API

core/src/ctxt.rs

@@ -154,9 +154,13 @@ impl Ctxt for Empty {
 }
 
 mod internal {
-    use core::{marker::PhantomData, ops::ControlFlow};
+    use core::marker::PhantomData;
 
-    use crate::{key::Key, props::Props, value::Value};
+    use crate::{
+        key::Key,
+        props::{ControlFlow, Props},
+        value::Value,
+    };
 
     pub struct Slot<T: ?Sized>(*const T, PhantomData<*mut fn()>);
 
@@ -171,7 +175,10 @@ mod internal {
     }
 
     impl<T: Props + ?Sized> Props for Slot<T> {
-        fn for_each<'a, F: FnMut(Key<'a>, Value<'a>) -> ControlFlow<()>>(&'a self, for_each: F) {
+        fn for_each<'a, F: FnMut(Key<'a>, Value<'a>) -> ControlFlow>(
+            &'a self,
+            for_each: F,
+        ) -> ControlFlow {
             self.get().for_each(for_each)
         }
     }
@@ -187,14 +194,11 @@ mod alloc_support {
     use super::*;
 
     mod internal {
-        use core::{marker::PhantomData, mem, ops::ControlFlow};
+        use core::{marker::PhantomData, mem};
 
         use crate::{
-            event::Event,
             key::Key,
-            props::{ErasedProps, Props},
-            template::Template,
-            time::Timestamp,
+            props::{ControlFlow, ErasedProps, Props},
             value::Value,
         };
 
@@ -233,10 +237,10 @@ mod alloc_support {
         }
 
         impl Props for ErasedCurrentProps {
-            fn for_each<'a, F: FnMut(Key<'a>, Value<'a>) -> ControlFlow<()>>(
+            fn for_each<'a, F: FnMut(Key<'a>, Value<'a>) -> ControlFlow>(
                 &'a self,
                 for_each: F,
-            ) {
+            ) -> ControlFlow {
                 self.get().for_each(for_each)
             }
         }

core/src/event.rs

@@ -1,21 +1,17 @@
-use core::{
-    fmt,
-    ops::{ControlFlow, Range},
-};
+use core::fmt;
 
 use crate::{
-    extent::Extent,
+    extent::{Extent, ToExtent},
     key::{Key, ToKey},
-    props::{ByRef, Chain, ErasedProps, Props},
+    props::{ByRef, Chain, ControlFlow, ErasedProps, Props},
     template::{Render, Template},
-    time::Timestamp,
     value::{ToValue, Value},
-    well_known::{MSG_KEY, TPL_KEY, TSS_KEY, TS_KEY},
+    well_known::{MSG_KEY, TPL_KEY},
 };
 
 #[derive(Clone)]
 pub struct Event<'a, P> {
-    extent: Option<Range<Timestamp>>,
+    extent: Extent,
     tpl: Template<'a>,
     props: P,
 }
@@ -35,16 +31,16 @@ impl<'a, P: Props> fmt::Debug for Event<'a, P> {
 }
 
 impl<'a, P> Event<'a, P> {
-    pub fn new(extent: impl Extent, tpl: Template<'a>, props: P) -> Self {
+    pub fn new(extent: impl ToExtent, tpl: Template<'a>, props: P) -> Self {
         Event {
-            extent: extent.extent(),
+            extent: extent.to_extent(),
             tpl,
             props,
         }
     }
 
-    pub fn extent(&self) -> Option<&Range<Timestamp>> {
-        self.extent.as_ref()
+    pub fn extent(&self) -> &Extent {
+        &self.extent
     }
 }
 
@@ -65,30 +61,8 @@ impl<'a, P: Props> Event<'a, P> {
         }
     }
 
-    pub fn for_each<'kv, F: FnMut(Key<'kv>, Value<'kv>) -> ControlFlow<()>>(
-        &'kv self,
-        mut for_each: F,
-    ) {
-        let mut reserved = || {
-            if let Some(ref ts) = self.extent {
-                if ts.start != ts.end {
-                    for_each(TSS_KEY.to_key(), ts.start.to_value())?;
-                }
-
-                for_each(TS_KEY.to_key(), ts.end.to_value())?;
-            }
-
-            for_each(TPL_KEY.to_key(), self.tpl.to_value())?;
-            for_each(MSG_KEY.to_key(), Msg::new_ref(self).to_value())?;
-
-            ControlFlow::Continue(())
-        };
-
-        if let ControlFlow::Break(()) = reserved() {
-            return;
-        }
-
-        self.props.for_each(for_each);
+    pub fn for_each<'kv, F: FnMut(Key<'kv>, Value<'kv>) -> ControlFlow>(&'kv self, for_each: F) {
+        let _ = Props::for_each(self, for_each);
     }
 
     pub fn props(&self) -> &P {
@@ -112,9 +86,23 @@ impl<'a, P: Props> Event<'a, P> {
     }
 }
 
+impl<'a, P> ToExtent for Event<'a, P> {
+    fn to_extent(&self) -> Extent {
+        self.extent.clone()
+    }
+}
+
 impl<'a, P: Props> Props for Event<'a, P> {
-    fn for_each<'kv, F: FnMut(Key<'kv>, Value<'kv>) -> ControlFlow<()>>(&'kv self, for_each: F) {
-        self.for_each(for_each)
+    fn for_each<'kv, F: FnMut(Key<'kv>, Value<'kv>) -> ControlFlow>(
+        &'kv self,
+        mut for_each: F,
+    ) -> ControlFlow {
+        self.extent.for_each(&mut for_each)?;
+
+        for_each(TPL_KEY.to_key(), self.tpl.to_value())?;
+        for_each(MSG_KEY.to_key(), Msg::new_ref(self).to_value())?;
+
+        self.props.for_each(for_each)
     }
 }
 

core/src/extent.rs

@@ -1,52 +1,97 @@
 use crate::{
     empty::Empty,
-    event::Event,
+    key::{Key, ToKey},
+    props::{ControlFlow, Props},
     time::{Clock, Timer, Timestamp},
+    value::{ToValue, Value},
+    well_known::{TIMESTAMP_KEY, TIMESTAMP_START_KEY},
 };
 use core::ops::Range;
 
-pub trait Extent {
-    fn extent(&self) -> Option<Range<Timestamp>>;
+#[derive(Debug, Clone)]
+pub struct Extent(Option<Range<Timestamp>>);
+
+impl Extent {
+    pub fn point(ts: Timestamp) -> Self {
+        Extent(Some(ts..ts))
+    }
+
+    pub fn span(ts: Range<Timestamp>) -> Self {
+        Extent(Some(ts))
+    }
+
+    pub fn empty() -> Self {
+        Extent(None)
+    }
+
+    pub fn to_point(&self) -> Option<&Timestamp> {
+        self.0.as_ref().map(|ts| &ts.end)
+    }
+
+    pub fn to_span(&self) -> Option<&Range<Timestamp>> {
+        self.0.as_ref().filter(|ts| ts.start != ts.end)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_none()
+    }
 }
 
-impl<'a, T: Extent + ?Sized> Extent for &'a T {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        (**self).extent()
+impl Props for Extent {
+    fn for_each<'kv, F: FnMut(Key<'kv>, Value<'kv>) -> ControlFlow>(
+        &'kv self,
+        mut for_each: F,
+    ) -> ControlFlow {
+        if let Some(ref ts) = self.0 {
+            if ts.start != ts.end {
+                for_each(TIMESTAMP_START_KEY.to_key(), ts.start.to_value())?;
+            }
+
+            for_each(TIMESTAMP_KEY.to_key(), ts.end.to_value())
+        } else {
+            ControlFlow::Continue(())
+        }
     }
 }
 
-impl Extent for Empty {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        None
+pub trait ToExtent {
+    fn to_extent(&self) -> Extent;
+}
+
+impl<'a, T: ToExtent + ?Sized> ToExtent for &'a T {
+    fn to_extent(&self) -> Extent {
+        (**self).to_extent()
     }
 }
 
-impl<'a, P> Extent for Event<'a, P> {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        self.extent().cloned()
+impl ToExtent for Empty {
+    fn to_extent(&self) -> Extent {
+        Extent::empty()
     }
 }
 
-impl Extent for Timestamp {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        Some(*self..*self)
+impl<T: ToExtent> ToExtent for Option<T> {
+    fn to_extent(&self) -> Extent {
+        self.as_ref()
+            .map(|ts| ts.to_extent())
+            .unwrap_or_else(Extent::empty)
     }
 }
 
-impl Extent for Range<Timestamp> {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        Some(self.clone())
+impl ToExtent for Timestamp {
+    fn to_extent(&self) -> Extent {
+        Extent::point(*self)
     }
 }
 
-impl<C: Clock> Extent for Timer<C> {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        self.extent()
+impl ToExtent for Range<Timestamp> {
+    fn to_extent(&self) -> Extent {
+        Extent::span(self.clone())
     }
 }
 
-impl<T: Extent> Extent for Option<T> {
-    fn extent(&self) -> Option<Range<Timestamp>> {
-        self.as_ref().and_then(|ts| ts.extent())
+impl<C: Clock> ToExtent for Timer<C> {
+    fn to_extent(&self) -> Extent {
+        self.extent()
     }
 }