Encapsulation of interval

Author: Kalashnikovni

sbg/interval.cpp

@@ -24,8 +24,8 @@ namespace SBG {
 namespace LIB {
 
 Interval::Interval() : begin_(1), step_(1), end_(0) {}
-Interval::Interval(NAT x) : begin_(x), step_(1), end_(x) {}
-Interval::Interval(NAT begin, NAT step, NAT end) 
+Interval::Interval(const NAT &x) : begin_(x), step_(1), end_(x) {}
+Interval::Interval(const NAT &begin, const NAT &step, const NAT &end) 
   : begin_(begin), step_(step), end_(end) 
 {
   if (end >= begin) {
@@ -43,9 +43,12 @@ Interval::Interval(NAT begin, NAT step, NAT end)
   }
 }
 
-member_imp(Interval, NAT, begin);
-member_imp(Interval, NAT, step);
-member_imp(Interval, NAT, end);
+NAT Interval::begin() const { return begin_; }
+NAT &Interval::begin_ref() { return begin_; }
+NAT Interval::step() const { return step_; }
+NAT &Interval::step_ref() { return step_; }
+NAT Interval::end() const { return end_; }
+NAT &Interval::end_ref() { return end_; }
 
 // Operators -------------------------------------------------------------------
 
@@ -69,7 +72,7 @@ bool Interval::operator<(const Interval &other) const
 std::ostream &operator<<(std::ostream &out, const Interval &i) 
 {
   out << "[" << Util::toStr(i.begin());
-  if (i.step_ != 1)
+  if (i.step() != 1)
     out << ":" << Util::toStr(i.step());
   out << ":" << Util::toStr(i.end()) << "]";
 
@@ -85,7 +88,7 @@ unsigned int Interval::cardinal() const
 
 bool Interval::isEmpty() const { return end_ < begin_; }
 
-bool Interval::isMember(NAT x) const
+bool Interval::isMember(const NAT &x) const
 {
   if (x < begin_ || x > end_)
     return false;
@@ -128,7 +131,7 @@ Interval Interval::intersection(const Interval &other)const
 
 // Extra operations ------------------------------------------------------------
 
-Interval Interval::offset(Util::NAT off) const
+Interval Interval::offset(const Util::NAT &off) const
 {
   Util::NAT new_b = begin_ + off, new_e = end_ + off;
 

sbg/interval.hpp

@@ -47,13 +47,16 @@ using MD_NAT = Util::MD_NAT;
 struct Interval {
   using MaybeInterval = std::optional<Interval>;
 
-  member_class(NAT, begin);
-  member_class(NAT, step);
-  member_class(NAT, end);
+  NAT begin() const;
+  NAT &begin_ref();
+  NAT step() const;
+  NAT &step_ref();
+  NAT end() const;
+  NAT &end_ref();
 
   Interval();
-  Interval(NAT x);
-  Interval(NAT begin, NAT step, NAT end);
+  Interval(const NAT &x);
+  Interval(const NAT &begin, const NAT &step, const NAT &end);
 
   bool operator==(const Interval &i) const;
   bool operator!=(const Interval &i) const;
@@ -64,15 +67,20 @@ struct Interval {
    */
   unsigned int cardinal() const;
   bool isEmpty() const;
-  bool isMember(NAT x) const;
+  bool isMember(const NAT &x) const;
   Interval intersection(const Interval &i2) const;
 
   /**
    * @brief Extra operations.
    */
-  Interval offset(Util::NAT off) const;
+  Interval offset(const Util::NAT &off) const;
   Interval least(const Interval &i2) const;
   MaybeInterval compact(const Interval &i2) const;
+
+  private:
+  NAT begin_;
+  NAT step_;
+  NAT end_;
 };
 std::ostream &operator<<(std::ostream &out, const Interval &i);