Adds LightweightEvent for making Event string fields in lazy.

Author: Steven Gu

analyzeme/src/event.rs

@@ -1,6 +1,6 @@
-use measureme::RawEvent;
+use crate::timestamp::Timestamp;
 use std::borrow::Cow;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct Event<'a> {
@@ -37,50 +37,3 @@ impl<'a> Event<'a> {
         }
     }
 }
-
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum Timestamp {
-    Interval { start: SystemTime, end: SystemTime },
-    Instant(SystemTime),
-}
-
-impl Timestamp {
-    pub fn from_raw_event(raw_event: &RawEvent, start_time: SystemTime) -> Timestamp {
-        if raw_event.is_instant() {
-            let t = start_time + Duration::from_nanos(raw_event.start_nanos());
-            Timestamp::Instant(t)
-        } else {
-            let start = start_time + Duration::from_nanos(raw_event.start_nanos());
-            let end = start_time + Duration::from_nanos(raw_event.end_nanos());
-            Timestamp::Interval { start, end }
-        }
-    }
-
-    pub fn contains(&self, t: SystemTime) -> bool {
-        match *self {
-            Timestamp::Interval { start, end } => t >= start && t < end,
-            Timestamp::Instant(_) => false,
-        }
-    }
-
-    pub fn is_instant(&self) -> bool {
-        match *self {
-            Timestamp::Interval { .. } => false,
-            Timestamp::Instant(_) => true,
-        }
-    }
-
-    pub fn start(&self) -> SystemTime {
-        match *self {
-            Timestamp::Interval { start, .. } => start,
-            Timestamp::Instant(t) => t,
-        }
-    }
-
-    pub fn end(&self) -> SystemTime {
-        match *self {
-            Timestamp::Interval { end, .. } => end,
-            Timestamp::Instant(t) => t,
-        }
-    }
-}

analyzeme/src/lib.rs

@@ -14,10 +14,14 @@
 //! [`ProfilingData::iter()`]: struct.ProfilingData.html#method.iter
 
 mod event;
+mod lightweight_event;
 mod profiling_data;
 mod stack_collapse;
+mod timestamp;
 pub mod testing_common;
 
-pub use crate::event::{Event, Timestamp};
+pub use crate::event::Event;
+pub use crate::lightweight_event::LightweightEvent;
 pub use crate::profiling_data::{ProfilingData, ProfilingDataBuilder};
 pub use crate::stack_collapse::collapse_stacks;
+pub use crate::timestamp::Timestamp;

analyzeme/src/lightweight_event.rs

@@ -0,0 +1,85 @@
+use crate::event::Event;
+use crate::profiling_data::ProfilingData;
+use crate::timestamp::Timestamp;
+use std::hash::{Hash, Hasher};
+use std::time::Duration;
+
+#[derive(Clone, Debug)]
+pub struct LightweightEvent<'a> {
+    pub data: &'a ProfilingData,
+    pub event_index: usize,
+    pub thread_id: u32,
+    pub timestamp: Timestamp,
+}
+
+impl<'a> LightweightEvent<'a> {
+    pub fn to_event(&self) -> Event<'a> {
+        self.data.decode_full_event(self.event_index)
+    }
+
+    /// Returns true if the time interval of `self` completely contains the
+    /// time interval of `other`.
+    pub fn contains(&self, other: &LightweightEvent) -> bool {
+        match self.timestamp {
+            Timestamp::Interval {
+                start: self_start,
+                end: self_end,
+            } => match other.timestamp {
+                Timestamp::Interval {
+                    start: other_start,
+                    end: other_end,
+                } => self_start <= other_start && other_end <= self_end,
+                Timestamp::Instant(other_t) => self_start <= other_t && other_t <= self_end,
+            },
+            Timestamp::Instant(_) => false,
+        }
+    }
+
+    pub fn duration(&self) -> Option<Duration> {
+        match self.timestamp {
+            Timestamp::Interval { start, end } => end.duration_since(start).ok(),
+            Timestamp::Instant(_) => None,
+        }
+    }
+}
+
+impl<'a> PartialEq for LightweightEvent<'a> {
+    fn eq(&self, other: &LightweightEvent<'a>) -> bool {
+        let LightweightEvent {
+            data,
+            event_index,
+            thread_id,
+            timestamp,
+        } = *self;
+
+        let LightweightEvent {
+            data: other_data,
+            event_index: other_event_index,
+            thread_id: other_thread_id,
+            timestamp: other_timestamp,
+        } = *other;
+
+        std::ptr::eq(data, other_data) &&
+            event_index == other_event_index &&
+            thread_id == other_thread_id &&
+            timestamp == other_timestamp
+    }
+}
+
+impl<'a> Eq for LightweightEvent<'a> {}
+
+impl<'a> Hash for LightweightEvent<'a> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let LightweightEvent {
+            data,
+            event_index,
+            thread_id,
+            timestamp,
+        } = *self;
+
+        std::ptr::hash(data, state);
+        event_index.hash(state);
+        thread_id.hash(state);
+        timestamp.hash(state);
+    }
+}