Create concept of CalendarDate/JulianDay

Author: marcosbento

Viewer/ecflowUI/src/VRepeatAttr.cpp

@@ -195,8 +195,8 @@ int VRepeatDateAttr::endIndex() const {
     if (node_ptr node = parent_->node()) {
         const Repeat& r = node->repeat();
         if (r.step() > 0) {
-            long jStart = ecf::calendar_date_to_julian_day(r.start());
-            long jEnd   = ecf::calendar_date_to_julian_day(r.end());
+            long jStart = ecf::CalendarDate(r.start()).as_julian_day().value();
+            long jEnd   = ecf::CalendarDate(r.end()).as_julian_day().value();
 
             int index = (jEnd - jStart) / r.step();
             long val  = jStart + index * r.step();
@@ -213,7 +213,9 @@ int VRepeatDateAttr::endIndex() const {
 int VRepeatDateAttr::currentIndex() const {
     if (node_ptr node = parent_->node()) {
         const Repeat& r = node->repeat();
-        int cur         = (ecf::calendar_date_to_julian_day(r.index_or_value()) - ecf::calendar_date_to_julian_day(r.start())) / r.step();
+        int cur         = (ecf::CalendarDate(r.index_or_value()).as_julian_day().value() -
+                   ecf::CalendarDate(r.start()).as_julian_day().value()) /
+                  r.step();
         return cur;
     }
     return 0;
@@ -239,7 +241,8 @@ std::string VRepeatDateAttr::value(int index) const {
     std::stringstream ss;
     if (node_ptr node = parent_->node()) {
         const Repeat& r = node->repeat();
-        ss << (ecf::julian_day_to_calendar_date(ecf::calendar_date_to_julian_day(r.start()) + index * r.step()));
+        auto date       = ecf::CalendarDate(r.start()) + (index * r.step());
+        ss << date.value();
     }
 
     return ss.str();
@@ -252,7 +255,7 @@ int VRepeatDateAttr::currentPosition() const {
             return -1;
         else if (r.value() == r.start())
             return 0;
-        else if (r.value() == r.end() || ecf::calendar_date_to_julian_day(r.value()) + r.step() > ecf::calendar_date_to_julian_day(r.end()))
+        else if (r.value() == r.end() || ecf::CalendarDate(r.value()) + r.step() > ecf::CalendarDate(r.end()))
             return 2;
         else
             return 1;
@@ -272,7 +275,7 @@ int VRepeatDateTimeAttr::endIndex() const {
         auto& r  = node->repeat();
         auto rng = ecf::make_range<RepeatDateTime>(r);
         auto idx = rng.end();
-        idx = std::min(idx, rng.size() - 1); // ensure idx is within range [0, size-1]
+        idx      = std::min(idx, rng.size() - 1); // ensure idx is within range [0, size-1]
         return idx;
     }
     return 0;

libs/attribute/src/ecflow/attribute/RepeatAttr.cpp

@@ -260,8 +260,7 @@ void RepeatDate::update_repeat_genvar_value() const {
             dow_.set_value(ecf::convert_to<std::string>(day_of_week));
 
             long last_value = last_valid_value();
-            long julian     = ecf::calendar_date_to_julian_day(last_value);
-            julian_.set_value(ecf::convert_to<std::string>(julian));
+            julian_.set_value(ecf::convert_to<std::string>(ecf::CalendarDate(last_value).as_julian_day().value()));
         }
         catch (std::exception& e) {
             std::stringstream ss;
@@ -304,17 +303,13 @@ long RepeatDate::valid_value(long value) const {
 }
 
 long RepeatDate::last_valid_value_minus(int val) const {
-    long last_value = last_valid_value();
-    long julian     = ecf::calendar_date_to_julian_day(last_value);
-    julian -= val;
-    return ecf::julian_day_to_calendar_date(julian);
+    auto result = ecf::CalendarDate(last_valid_value()) - val;
+    return result.value();
 }
 
 long RepeatDate::last_valid_value_plus(int val) const {
-    long last_value = last_valid_value();
-    long julian     = ecf::calendar_date_to_julian_day(last_value);
-    julian += val;
-    return ecf::julian_day_to_calendar_date(julian);
+    auto result = ecf::CalendarDate(last_valid_value()) + val;
+    return result.value();
 }
 
 void RepeatDate::reset() {
@@ -384,11 +379,8 @@ std::string RepeatDate::value_as_string(int index) const {
 }
 
 std::string RepeatDate::next_value_as_string() const {
-    long val = last_valid_value();
-
-    long julian = ecf::calendar_date_to_julian_day(val);
-    julian += delta_;
-    val = ecf::julian_day_to_calendar_date(julian);
+    auto result = ecf::CalendarDate(last_valid_value()) + delta_;
+    long val    = result.value();
 
     try {
         return ecf::convert_to<std::string>(valid_value(val));
@@ -399,11 +391,8 @@ std::string RepeatDate::next_value_as_string() const {
 }
 
 std::string RepeatDate::prev_value_as_string() const {
-    long val = last_valid_value();
-
-    long julian = ecf::calendar_date_to_julian_day(val);
-    julian -= delta_;
-    val = ecf::julian_day_to_calendar_date(julian);
+    auto result = ecf::CalendarDate(last_valid_value()) - delta_;
+    long val    = result.value();
 
     try {
         return ecf::convert_to<std::string>(valid_value(val));
@@ -414,9 +403,8 @@ std::string RepeatDate::prev_value_as_string() const {
 }
 
 void RepeatDate::increment() {
-    long julian = ecf::calendar_date_to_julian_day(value_);
-    julian += delta_;
-    set_value(ecf::julian_day_to_calendar_date(julian));
+    auto result = ecf::CalendarDate(last_valid_value()) + delta_;
+    set_value(result.value());
 }
 
 void RepeatDate::change(const std::string& newdate) {
@@ -469,8 +457,8 @@ void RepeatDate::changeValue(long the_new_date) {
     }
 
     // Check new value is in step. ECFLOW-325 repeat date 7
-    long julian_new_date = ecf::calendar_date_to_julian_day(the_new_date);
-    long julian_start    = ecf::calendar_date_to_julian_day(start_);
+    long julian_new_date = ecf::CalendarDate(the_new_date).as_julian_day().value();
+    long julian_start    = ecf::CalendarDate(start_).as_julian_day().value();
     long diff            = julian_new_date - julian_start;
     if (diff % delta_ != 0) {
         std::stringstream ss;
@@ -913,8 +901,7 @@ void RepeatDateList::update_repeat_genvar_value() const {
             dom_.set_value(ecf::convert_to<std::string>(day_of_month));
             dow_.set_value(ecf::convert_to<std::string>(day_of_week));
 
-            long last_value = last_valid_value();
-            long julian     = ecf::calendar_date_to_julian_day(last_value);
+            long julian = CalendarDate(last_valid_value()).as_julian_day().value();
             julian_.set_value(ecf::convert_to<std::string>(julian));
         }
         catch (std::exception& e) {
@@ -1001,19 +988,15 @@ long RepeatDateList::last_valid_value_minus(int val) const {
     if (last_value == 0)
         return 0;
 
-    long julian = ecf::calendar_date_to_julian_day(last_value);
-    julian -= val;
-    return ecf::julian_day_to_calendar_date(julian);
+    return (CalendarDate(last_value) - val).value();
 }
 
 long RepeatDateList::last_valid_value_plus(int val) const {
     long last_value = last_valid_value();
     if (last_value == 0)
         return 0;
 
-    long julian = ecf::calendar_date_to_julian_day(last_value);
-    julian += val;
-    return ecf::julian_day_to_calendar_date(julian);
+    return (CalendarDate(last_value) + val).value();
 }
 
 void RepeatDateList::setToLastValue() {

libs/attribute/src/ecflow/attribute/RepeatRange.hpp

@@ -55,25 +55,25 @@ struct Range<RepeatDate>
 
     iterator begin() const { return 0; }
     iterator end() const {
-        int i = ecf::calendar_date_to_julian_day(r_.start());
-        int j = ecf::calendar_date_to_julian_day(r_.end());
+        int i = ecf::CalendarDate(r_.start()).as_julian_day().value();
+        int j = ecf::CalendarDate(r_.end()).as_julian_day().value();
         int s = r_.step();
         int d = (j - i) + 1;
         return (d / s) + ((d % s == 0) ? 0 : 1);
     }
     iterator current_index() const {
-        auto i   = ecf::calendar_date_to_julian_day(r_.start());
+        auto i   = ecf::CalendarDate(r_.start()).as_julian_day().value();
         auto s   = r_.step();
-        auto v   = ecf::calendar_date_to_julian_day(r_.value());
+        auto v   = ecf::CalendarDate(r_.value()).as_julian_day().value();
         auto idx = (v - i) / s;
         return idx;
     }
 
     value_type current_value() const { return r_.value(); }
 
     value_type at(iterator i) const {
-        int j = ecf::calendar_date_to_julian_day(r_.start());
-        return ecf::julian_day_to_calendar_date(j + i * r_.step());
+        int j = ecf::CalendarDate(r_.start()).as_julian_day().value();
+        return ecf::JulianDay(j + i * r_.step()).as_calendar_date().value();
     }
 
     size_type size() const { return end() - begin(); }

libs/attribute/test/TestRepeat.cpp

@@ -530,7 +530,7 @@ BOOST_AUTO_TEST_CASE(generated_variables) {
     {
         const Variable& var = rep.find_gen_variable("YMD_JULIAN");
         BOOST_CHECK_MESSAGE(!var.empty(), "Did not find generated variable YMD_JULIAN");
-        std::string expected = ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20090916));
+        std::string expected = ecf::convert_to<std::string>(ecf::CalendarDate(20090916).as_julian_day().value());
         BOOST_CHECK_MESSAGE(var.theValue() == expected, "expected " << expected << " but found " << var.theValue());
     }
 }
@@ -597,13 +597,13 @@ BOOST_AUTO_TEST_CASE(more_generated_variables) {
     expected_day_of_week.emplace_back("5");
 
     std::vector<std::string> expected_julian;
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20161231)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170101)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170102)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170103)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170104)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170105)));
-    expected_julian.push_back(ecf::convert_to<std::string>(ecf::calendar_date_to_julian_day(20170106)));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20161231).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170101).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170102).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170103).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170104).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170105).as_julian_day().value()));
+    expected_julian.push_back(ecf::convert_to<std::string>(ecf::CalendarDate(20170106).as_julian_day().value()));
 
     for (int i = 0; i < 7; i++) {
 

libs/core/src/ecflow/core/Calendar.cpp

@@ -32,7 +32,9 @@ using namespace boost::posix_time;
 
 namespace ecf {
 
-long julian_day_to_calendar_date(long jdate) {
+namespace implementation {
+
+CalendarDate::value_t julian_day_to_calendar_date(long jdate) {
     long x = 0, y = 0, d = 0, m = 0, e = 0;
     long day = 0, month = 0, year = 0;
 
@@ -62,7 +64,7 @@ long julian_day_to_calendar_date(long jdate) {
     return year * 10000 + month * 100 + day;
 }
 
-long calendar_date_to_julian_day(long ddate) {
+JulianDay::value_t calendar_date_to_julian_day(long ddate) {
     long m1 = 0, y1 = 0, a = 0, b = 0, c = 0, d = 0, j1 = 0;
 
     long month = 0, day = 0, year = 0;
@@ -90,6 +92,113 @@ long calendar_date_to_julian_day(long ddate) {
     return j1;
 }
 
+} // namespace implementation
+
+JulianDay CalendarDate::as_julian_day() const {
+    return JulianDay(implementation::calendar_date_to_julian_day(value_));
+}
+
+CalendarDate JulianDay::as_calendar_date() const {
+    return CalendarDate(implementation::julian_day_to_calendar_date(value_));
+}
+
+bool operator==(const CalendarDate& lhs, const CalendarDate& rhs) {
+    return lhs.value() == rhs.value();
+}
+
+bool operator==(const CalendarDate& lhs, const JulianDay& rhs) {
+    return lhs.as_julian_day() == rhs;
+}
+
+bool operator==(const JulianDay& lhs, const CalendarDate& rhs) {
+    return lhs == rhs.as_julian_day();
+}
+
+bool operator==(const JulianDay& lhs, const JulianDay& rhs) {
+    return lhs.value() == rhs.value();
+}
+
+bool operator<(const CalendarDate& lhs, const CalendarDate& rhs) {
+    return lhs.as_julian_day() < rhs.as_julian_day();
+}
+
+bool operator<=(const CalendarDate& lhs, const CalendarDate& rhs) {
+    return lhs.as_julian_day() <= rhs.as_julian_day();
+}
+
+bool operator>(const CalendarDate& lhs, const CalendarDate& rhs) {
+    return lhs.as_julian_day() > rhs.as_julian_day();
+}
+
+bool operator>=(const CalendarDate& lhs, const CalendarDate& rhs) {
+    return lhs.as_julian_day() >= rhs.as_julian_day();
+}
+
+bool operator<(const JulianDay& lhs, const JulianDay& rhs) {
+    return lhs.value() < rhs.value();
+}
+
+bool operator<=(const JulianDay& lhs, const JulianDay& rhs) {
+    return lhs.value() <= rhs.value();
+}
+
+bool operator>(const JulianDay& lhs, const JulianDay& rhs) {
+    return lhs.value() > rhs.value();
+}
+
+bool operator>=(const JulianDay& lhs, const JulianDay& rhs) {
+    return lhs.value() >= rhs.value();
+}
+
+CalendarDate& operator+=(CalendarDate& lhs, CalendarDate::value_t rhs) {
+    auto jd    = lhs.as_julian_day() + rhs;
+    lhs.value_ = jd.as_calendar_date().value();
+    return lhs;
+}
+
+CalendarDate& operator-=(CalendarDate& lhs, CalendarDate::value_t rhs) {
+    auto jd    = lhs.as_julian_day() - rhs;
+    lhs.value_ = jd.as_calendar_date().value();
+    return lhs;
+}
+
+CalendarDate operator+(const CalendarDate& lhs, CalendarDate::value_t rhs) {
+    auto result = lhs;
+    return result += rhs;
+}
+
+CalendarDate operator-(const CalendarDate& lhs, CalendarDate::value_t rhs) {
+    auto result = lhs;
+    return result -= rhs;
+}
+
+JulianDay& operator+=(JulianDay& lhs, JulianDay::value_t rhs) {
+    lhs.value_ += rhs;
+    return lhs;
+}
+
+JulianDay& operator-=(JulianDay& lhs, JulianDay::value_t rhs) {
+    lhs.value_ -= rhs;
+    return lhs;
+}
+
+JulianDay operator+(const JulianDay& lhs, JulianDay::value_t rhs) {
+    return JulianDay(lhs.value() + rhs);
+}
+
+JulianDay operator-(const JulianDay& lhs, JulianDay::value_t rhs) {
+    return JulianDay(lhs.value() - rhs);
+}
+
+std::ostream& operator<<(std::ostream& os, const CalendarDate& cd) {
+    os << cd.value();
+    return os;
+}
+std::ostream& operator<<(std::ostream& os, const JulianDay& jd) {
+    os << jd.value();
+    return os;
+}
+
 Calendar::Calendar() = default;
 
 Calendar::Calendar(const Calendar& rhs) {