Extract best matching config entry

netpod/src/range/evrange.rs

@@ -1,5 +1,6 @@
 use crate::timeunits::SEC;
 use crate::Dim0Kind;
+use crate::TsNano;
 use chrono::DateTime;
 use chrono::TimeZone;
 use chrono::Utc;
@@ -23,19 +24,28 @@ pub struct NanoRange {
 
 impl fmt::Debug for NanoRange {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let beg = chrono::Utc
+        if true {
-            .timestamp_opt((self.beg / SEC) as i64, (self.beg % SEC) as u32)
+            let beg = TsNano(self.beg);
-            .earliest();
+            let end = TsNano(self.end);
-        let end = chrono::Utc
-            .timestamp_opt((self.end / SEC) as i64, (self.end % SEC) as u32)
-            .earliest();
-        if let (Some(a), Some(b)) = (beg, end) {
-            f.debug_struct("NanoRange").field("beg", &a).field("end", &b).finish()
-        } else {
             f.debug_struct("NanoRange")
                 .field("beg", &beg)
                 .field("end", &end)
                 .finish()
+        } else {
+            let beg = chrono::Utc
+                .timestamp_opt((self.beg / SEC) as i64, (self.beg % SEC) as u32)
+                .earliest();
+            let end = chrono::Utc
+                .timestamp_opt((self.end / SEC) as i64, (self.end % SEC) as u32)
+                .earliest();
+            if let (Some(a), Some(b)) = (beg, end) {
+                f.debug_struct("NanoRange").field("beg", &a).field("end", &b).finish()
+            } else {
+                f.debug_struct("NanoRange")
+                    .field("beg", &beg)
+                    .field("end", &end)
+                    .finish()
+            }
         }
     }
 }
@@ -51,6 +61,14 @@ impl NanoRange {
     pub fn delta(&self) -> u64 {
         self.end - self.beg
     }
+
+    pub fn beg(&self) -> u64 {
+        self.beg
+    }
+
+    pub fn end(&self) -> u64 {
+        self.end
+    }
 }
 
 impl TryFrom<&SeriesRange> for NanoRange {

parse/src/channelconfig.rs

@@ -465,7 +465,6 @@ pub fn extract_matching_config_entry<'a>(
         .map({
             let mut nx = None;
             move |(i, x)| {
-                debug!("MAP ENTRY  {i:3}  {:?}", x.ts);
                 let k = nx.clone();
                 nx = Some(x.ts.clone());
                 (i, x, k)
@@ -477,40 +476,43 @@ pub fn extract_matching_config_entry<'a>(
         .into_iter()
         .rev()
         .map(|(i, e, tsn)| {
-            //debug!("LOOK AT CONFIG ENTRY  {:3}  {:?}  {:?}", i, e.ts, tsn);
+            if let Some(ts2) = tsn.clone() {
-            let ret = if let Some(ts2) = tsn.clone() {
+                if e.ts.ns() < range.end() {
-                if e.ts.ns() < range.end {
+                    let p = if e.ts.ns() < range.beg() {
-                    let p = if e.ts.ns() < range.beg { range.beg } else { e.ts.ns() };
+                        range.beg()
-                    let q = if ts2.ns() < range.end { ts2.ns() } else { range.end };
+                    } else {
-                    //debug!("P/Q  {:?}  {:?}", TsNano(q - p), TsNano(p - q));
+                        e.ts.ns()
+                    };
+                    let q = if ts2.ns() < range.beg() {
+                        range.beg()
+                    } else {
+                        if ts2.ns() < range.end() {
+                            ts2.ns()
+                        } else {
+                            range.end()
+                        }
+                    };
                     (i, TsNano(q - p), e)
                 } else {
                     (i, TsNano(0), e)
                 }
             } else {
-                if e.ts.ns() < range.end {
+                if e.ts.ns() < range.end() {
-                    if e.ts.ns() < range.beg {
+                    if e.ts.ns() < range.beg() {
                         (i, TsNano(range.delta()), e)
                     } else {
-                        (i, TsNano(range.end - e.ts.ns()), e)
+                        (i, TsNano(range.end() - e.ts.ns()), e)
                     }
                 } else {
                     (i, TsNano(0), e)
                 }
-            };
+            }
-            debug!("LOOK AT CONFIG ENTRY  {:3}  {:?}  {:?}  {:?}", i, e.ts, tsn, ret.1);
-            ret
         })
         .collect();
 
     c.sort_unstable_by_key(|x| u64::MAX - x.1.ns());
 
-    for (i, dt, e) in &c[..c.len().min(3)] {
-        debug!("FOUND CONFIG IN ORDER  {}  {:?}  {:?}", i, dt, e.ts);
-    }
-
     if let Some(&(i, _, _)) = c.first() {
-        // TODO remove temporary
         Ok(MatchingConfigEntry::Single(&channel_config.entries[i]))
     } else {
         Ok(MatchingConfigEntry::None)