incomplete solution for bitfield removal - NA is not yet handled correctly

Author: lsilvest

inst/include/nanotime/interval.hpp

@@ -11,114 +11,101 @@ namespace nanotime {
 
   struct interval {
 
-#ifdef WORDS_BIGENDIAN
-    constexpr interval() : s(0), sopen(0), e(0), eopen(0) { }
-#else
-    constexpr interval() : sopen(0), s(0), eopen(0), e(0) { }
-#endif
+    constexpr interval() : s_impl(0), e_impl(0) { }
 
-    interval(dtime s_p, dtime e_p, int sopen_p, int eopen_p)
-#ifdef WORDS_BIGENDIAN
-      : s(s_p.time_since_epoch().count()), sopen(sopen_p),
-        e(e_p.time_since_epoch().count()), eopen(eopen_p) {
-#else
-      : sopen(sopen_p), s(s_p.time_since_epoch().count()),
-        eopen(eopen_p), e(e_p.time_since_epoch().count()) {
-#endif
+    interval(dtime s_p, dtime e_p, int sopen_p, int eopen_p) :
+      s_impl(s_p.time_since_epoch().count()),
+      e_impl(e_p.time_since_epoch().count())
+    {
+      if (sopen_p) {
+        s_impl |= std::int64_t{1} << 63;
+      }
+      if (eopen_p) {
+        e_impl |= std::int64_t{1} << 63;
+      }
+      
       // if any of the constructor parameters is NA, we construct an NA interval:
       if (s_p.time_since_epoch() == duration::min() || e_p.time_since_epoch() == duration::min() ||
           sopen_p == NA_INTEGER || eopen_p == NA_INTEGER) {
-        s = IVAL_NA;
-        e = IVAL_NA;
+        s_impl = IVAL_NA;
+        e_impl = IVAL_NA;
       } else {
         if (s_p.time_since_epoch().count() < IVAL_MIN || e_p.time_since_epoch().count() < IVAL_MIN) {
-          s = IVAL_NA;
-          e = IVAL_NA;
+          s_impl= IVAL_NA;
+          e_impl = IVAL_NA;
           Rf_warning("NAs produced by time overflow (remember that interval times are coded with 63 bits)");  
         }
         if (s_p.time_since_epoch().count() > IVAL_MAX || e_p.time_since_epoch().count() > IVAL_MAX) {
-          s = IVAL_NA;
-          e = IVAL_NA;
+          s_impl = IVAL_NA;
+          e_impl = IVAL_NA;
           Rf_warning("NAs produced by time overflow (remember that interval times are coded with 63 bits)");
         }
-        if (s > e) {
+        if (e() < s()) {
           std::stringstream ss;
-          ss << "interval end (" << e << ") smaller than interval start (" << s << ")";
+          ss << "interval end (" << e() << ") smaller than interval start (" << s() << ")";
           throw std::range_error(ss.str());
         }
       }
     }
 
-    // interval(std::int64_t s_p, std::int64_t e_p, bool sopen_p, bool eopen_p)
-    //   : sopen(sopen_p), s(s_p), eopen(eopen_p), e(e_p) {
-    //   if (s > e) {
-    //     std::stringstream ss;
-    //     ss << "interval end (" << e << ") smaller than interval start (" << s << ")";
-    //     throw std::range_error(ss.str());
-    //   }
-    // }
-
-    dtime getStart() const { return dtime(duration(s)); }
-    dtime getEnd() const { return dtime(duration(e)); }
-    bool isNA() const { return s == IVAL_NA; }
-  
-#ifdef WORDS_BIGENDIAN
-    std::int64_t s : 63;
-    bool sopen : 1; // encode if the interval's start boundary is open (true) or closed (false)
-    std::int64_t e : 63;
-    bool eopen : 1; // encode if the interval's end   boundary is open (true) or closed (false)
-#else
-    bool sopen : 1; // encode if the interval's start boundary is open (true) or closed (false)
-    std::int64_t s : 63;
-    bool eopen : 1; // encode if the interval's end   boundary is open (true) or closed (false)
-    std::int64_t e : 63;
-#endif
-
+    dtime getStart() const { return dtime(duration(s_impl)); }
+    dtime getEnd() const { return dtime(duration(e_impl)); }
+    bool sopen() const { return (s_impl & (std::int64_t{1} << 63)) != 0; }
+    bool eopen() const { return (e_impl & (std::int64_t{1} << 63)) != 0; }
+    std::int64_t s() const { return s_impl & ~(std::int64_t{1} << 63); }
+    std::int64_t e() const { return e_impl & ~(std::int64_t{1} << 63); }
+    
+    bool isNA() const { return s_impl == IVAL_NA; }
+    
     static const std::int64_t IVAL_MAX =  4611686018427387903LL;
     static const std::int64_t IVAL_MIN = -4611686018427387903LL;
-    static const std::int64_t IVAL_NA  = -4611686018427387904LL;
+    static const std::int64_t IVAL_NA  = -9223372036854775807LL - 1;
+
+  private:
+    std::int64_t s_impl;    // start of ival; last bit encodes if boundary is open (1) or closed (0)
+    std::int64_t e_impl;    // end of ival; last bit encodes if boundary is open (1) or closed (0)    
   };
 
   // operators:
 
   inline duration operator-(const interval& i1, const interval& i2) {
-    return duration(i1.s - i2.s);
+    return duration(i1.s() - i2.s());
   }
 
   inline bool operator==(const interval& i1, const interval& i2) {
-    return i1.s == i2.s && i1.e == i2.e && i1.sopen == i2.sopen &&
-      i1.eopen == i2.eopen;
+    return i1.s() == i2.s() && i1.e() == i2.e()  && i1.sopen() == i2.sopen() &&
+      i1.eopen() == i2.eopen();
   }
 
   inline bool operator!=(const interval& i1, const interval& i2) {
     return !(i1 == i2);
   }
 
   inline bool operator<=(const interval& i1, const interval& i2) {
-    if (i1.s < i2.s) return true;
-    if (i1.s == i2.s) {
-      if (!i1.sopen &&  i2.sopen) return true;
-      if (i1.sopen  && !i2.sopen) return false;
-      // here we know that s1.sopen == s2.sopen
-      if (i1.e < i2.e) return true;
-      if (i1.e == i2.e) {
-        if (i1.eopen ==  i2.eopen) return true;
-        if (i1.eopen && !i2.eopen) return true;
+    if (i1.s() < i2.s()) return true;
+    if (i1.s() == i2.s()) {
+      if (!i1.sopen() &&  i2.sopen()) return true;
+      if (i1.sopen()  && !i2.sopen()) return false;
+      // here we know that s1.sopen() == s2.sopen()
+      if (i1.e() < i2.e()) return true;
+      if (i1.e() == i2.e()) {
+        if (i1.eopen() ==  i2.eopen()) return true;
+        if (i1.eopen() && !i2.eopen()) return true;
       }
     }
     return false;
   }
 
   inline bool operator<(const interval& i1, const interval& i2) {
-    if (i1.s < i2.s) return true;
-    if (i1.s == i2.s) {
-      if (!i1.sopen &&  i2.sopen) return true;
-      if (i1.sopen  && !i2.sopen) return false;
-      // here we know that s1.sopen == s2.sopen
-      if (i1.e < i2.e) return true;
-      if (i1.e == i2.e) {
-        if (i1.eopen ==  i2.eopen) return false;
-        if (i1.eopen && !i2.eopen) return true;
+    if (i1.s() < i2.s()) return true;
+    if (i1.s() == i2.s()) {
+      if (!i1.sopen() &&  i2.sopen()) return true;
+      if (i1.sopen()  && !i2.sopen()) return false;
+      // here we know that s1.sopen() == s2.sopen()
+      if (i1.e() < i2.e()) return true;
+      if (i1.e() == i2.e()) {
+        if (i1.eopen() ==  i2.eopen()) return false;
+        if (i1.eopen() && !i2.eopen()) return true;
       }
     }
     return false;
@@ -133,30 +120,30 @@ namespace nanotime {
   }
 
   inline bool operator<(const dtime& i1, const interval& i2) {
-    if (i1.time_since_epoch().count() < i2.s) return true;
-    if (i1.time_since_epoch().count() == i2.s) return i2.sopen;
+    if (i1.time_since_epoch().count() < i2.s()) return true;
+    if (i1.time_since_epoch().count() == i2.s()) return i2.sopen();
     return false;
   }
 
   inline bool operator>(const dtime& i1, const interval& i2) {
-    if (i1.time_since_epoch().count() >  i2.e) return true;
-    if (i1.time_since_epoch().count() == i2.e) return i2.eopen;
+    if (i1.time_since_epoch().count() >  i2.e()) return true;
+    if (i1.time_since_epoch().count() == i2.e()) return i2.eopen();
     return false;
   }
 
   inline interval operator+(const interval& i, const duration d) {
     // test duration is not > 63-bits, and after that the constructor can test for overflow:
-    return interval(i.getStart() + d, i.getEnd() + d, i.sopen, i.eopen);
+    return interval(i.getStart() + d, i.getEnd() + d, i.sopen(), i.eopen());
   }
 
   inline interval operator-(const interval& i, const duration d) {
     // test duration is not > 63-bits, and after that the constructor can test for underflow:
-    return interval(i.getStart() - d, i.getEnd() - d, i.sopen, i.eopen);
+    return interval(i.getStart() - d, i.getEnd() - d, i.sopen(), i.eopen());
   }
 
   inline interval operator+(const duration d, const interval& i) {
     // test duration is not > 63-bits, and after that the constructor can test for overflow:
-    return interval(i.getStart() + d, i.getEnd() + d, i.sopen, i.eopen);
+    return interval(i.getStart() + d, i.getEnd() + d, i.sopen(), i.eopen());
   }
 
   // interval components comparators:
@@ -195,10 +182,10 @@ namespace nanotime {
 
   // interval comparators:
   inline bool start_lt(const interval& i1, const interval& i2) {
-    return start_lt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen);
+    return start_lt(i1.getStart(), i1.sopen(), i2.getStart(), i2.sopen());
   }
   inline bool start_gt(const interval& i1, const interval& i2) {
-    return start_gt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen);
+    return start_gt(i1.getStart(), i1.sopen(), i2.getStart(), i2.sopen());
   }
   inline bool start_le(const interval& i1, const interval& i2) {
     return !start_gt(i1,i2);
@@ -207,10 +194,10 @@ namespace nanotime {
     return !start_lt(i1,i2);
   }
   inline bool end_lt(const interval& i1, const interval& i2) {
-    return end_lt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen);
+    return end_lt(i1.getEnd(), i1.eopen(), i2.getEnd(), i2.eopen());
   }
   inline bool end_gt(const interval& i1, const interval& i2) {
-    return end_gt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen);
+    return end_gt(i1.getEnd(), i1.eopen(), i2.getEnd(), i2.eopen());
   }
   inline bool end_le(const interval& i1, const interval& i2) {
     return !end_gt(i1,i2);
@@ -222,10 +209,10 @@ namespace nanotime {
   /// True if the end of 'i1' is smaller than the start of 'i2'. This
   /// tests that 'i1' and 'i2' are disjoint and 'i2' is after 'i1'.
   inline bool end_lt_start(const interval& i1, const interval& i2) {
-    return end_lt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen);
+    return end_lt(i1.getEnd(), i1.eopen(), i2.getStart(), i2.sopen());
   }
   inline bool end_gt_start(const interval& i1, const interval& i2) {
-    return end_gt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen);
+    return end_gt(i1.getEnd(), i1.eopen(), i2.getStart(), i2.sopen());
   }
   /// True if the end of 'i1' is greater or equal than the start of
   /// 'i2'. This tests that 'i1' and 'i2' "touch" and that 'i2' is
@@ -277,10 +264,10 @@ namespace nanotime {
 
   // interval comparators:
   inline bool union_start_lt(const interval& i1, const interval& i2) {
-    return union_start_lt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen);
+    return union_start_lt(i1.getStart(), i1.sopen(), i2.getStart(), i2.sopen());
   }
   inline bool union_start_gt(const interval& i1, const interval& i2) {
-    return union_start_gt(i1.getStart(), i1.sopen, i2.getStart(), i2.sopen);
+    return union_start_gt(i1.getStart(), i1.sopen(), i2.getStart(), i2.sopen());
   }
   inline bool union_start_le(const interval& i1, const interval& i2) {
     return !union_start_gt(i1,i2);
@@ -289,10 +276,10 @@ namespace nanotime {
     return !union_start_lt(i1,i2);
   }
   inline bool union_end_lt(const interval& i1, const interval& i2) {
-    return union_end_lt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen);
+    return union_end_lt(i1.getEnd(), i1.eopen(), i2.getEnd(), i2.eopen());
   }
   inline bool union_end_gt(const interval& i1, const interval& i2) {
-    return union_end_gt(i1.getEnd(), i1.eopen, i2.getEnd(), i2.eopen);
+    return union_end_gt(i1.getEnd(), i1.eopen(), i2.getEnd(), i2.eopen());
   }
   inline bool union_end_le(const interval& i1, const interval& i2) {
     return !union_end_gt(i1,i2);
@@ -304,10 +291,10 @@ namespace nanotime {
   /// True if the end of 'i1' is smaller than the start of 'i2'. This
   /// tests that 'i1' and 'i2' are disjoint and 'i2' is after 'i1'.
   inline bool union_end_lt_start(const interval& i1, const interval& i2) {
-    return union_end_lt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen);
+    return union_end_lt(i1.getEnd(), i1.eopen(), i2.getStart(), i2.sopen());
   }
   inline bool union_end_gt_start(const interval& i1, const interval& i2) {
-    return union_end_gt(i1.getEnd(), i1.eopen, i2.getStart(), i2.sopen);
+    return union_end_gt(i1.getEnd(), i1.eopen(), i2.getStart(), i2.sopen());
   }
   /// True if the end of 'i1' is greater or equal than the start of
   /// 'i2'. This tests that 'i1' and 'i2' "touch" and that 'i2' is

inst/include/nanotime/period.hpp

@@ -125,8 +125,8 @@ namespace nanotime {
 
 
   inline interval plus (const interval& i, const period& p,   const std::string& z) {
-    return interval(plus(dtime{duration{i.s}}, p, z),
-                    plus(dtime{duration{i.e}}, p, z), i.sopen, i.eopen);
+    return interval(plus(dtime{duration{i.s()}}, p, z),
+                    plus(dtime{duration{i.e()}}, p, z), i.sopen(), i.eopen());
   }
   inline interval plus (const period& p,   const interval& i, const std::string& z) {
     return plus(i, p, z);