feat: quantity point-like support

test/unit_test/static/chrono_test.cpp

@@ -23,6 +23,7 @@
 #include "test_tools.h"
 #include <units/chrono.h>
 #include <units/physical/si/derived/speed.h>
+#include <units/quantity_point.h>
 
 namespace {
 
@@ -30,8 +31,13 @@ using namespace units;
 using namespace units::physical;
 using namespace units::physical::si::literals;
 using namespace std::chrono_literals;
+using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
+using sys_days = std::chrono::time_point<std::chrono::system_clock,
+  std::chrono::duration<long, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>>;
+template<typename U, typename Rep = double> using time_point = quantity_point<si::dim_time, U, Rep>;
 
 static_assert(QuantityLike<std::chrono::seconds>);
+static_assert(QuantityPointLike<sys_seconds>);
 
 // construction - same rep type
 static_assert(std::constructible_from<si::time<si::second, std::chrono::seconds::rep>, std::chrono::seconds>);
@@ -42,6 +48,14 @@ static_assert(std::constructible_from<si::time<si::second, std::chrono::hours::r
 static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second, std::chrono::hours::rep>>);
 static_assert(!std::constructible_from<si::time<si::hour, std::chrono::seconds::rep>, std::chrono::seconds>);
 static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour, std::chrono::seconds::rep>>);
+static_assert(std::constructible_from<time_point<si::second, sys_seconds::rep>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::second, sys_seconds::rep>>);
+static_assert(std::constructible_from<time_point<si::day, sys_days::rep>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::day, sys_days::rep>>);
+static_assert(std::constructible_from<time_point<si::second, sys_days::rep>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::second, sys_days::rep>>);
+static_assert(!std::constructible_from<time_point<si::day, sys_seconds::rep>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::day, sys_seconds::rep>>);
 
 // construction - different rep type (integral to a floating-point)
 static_assert(std::constructible_from<si::time<si::second>, std::chrono::seconds>);
@@ -50,15 +64,25 @@ static_assert(std::constructible_from<si::time<si::second>, std::chrono::hours>)
 static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second>>);
 static_assert(std::constructible_from<si::time<si::hour>, std::chrono::seconds>);
 static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour>>);
+static_assert(std::constructible_from<time_point<si::second>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::second>>);
+static_assert(std::constructible_from<time_point<si::second>, sys_days>);
+static_assert(!std::convertible_to<sys_days, time_point<si::second>>);
+static_assert(std::constructible_from<time_point<si::day>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<si::day>>);
 
 
 // CTAD
 static_assert(is_same_v<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
 static_assert(is_same_v<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
+static_assert(is_same_v<decltype(quantity_point{sys_seconds{1s}}), time_point<si::second, sys_seconds::rep>>);
+static_assert(is_same_v<decltype(quantity_point{sys_days{sys_days::duration{1}}}), time_point<si::day, sys_days::rep>>);
 
 // operators
 static_assert(quantity{1s} + 1_q_s == 2_q_s);
 static_assert(quantity{1s} + 1_q_min == 61_q_s);
 static_assert(10_q_m / quantity{2s} == 5_q_m_per_s);
+static_assert(quantity_point{sys_seconds{1s}} + 1_q_s == quantity_point{2_q_s});
+static_assert(quantity_point{sys_seconds{1s}} + 1_q_min == quantity_point{61_q_s});
 
 }  // namespace

test/unit_test/static/quantity_point_kind_test.cpp

@@ -39,6 +39,7 @@ using namespace units;
 namespace si = physical::si;
 using namespace si;
 using namespace unit_constants;
+using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
 
 constexpr auto cgs_cm = cgs::unit_constants::cm;
 
@@ -303,6 +304,8 @@ static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(quantity_p
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(quantity_point(dimensionless<percent, int>(1))));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(quantity_point(dimensionless<percent, double>(1))));
 static_assert(!constructible_or_convertible_from<nth_apple<one, double>>(quantity_point(1.0 * s)));
+
+static_assert(construct_from_only<quantity_point_kind<time_point_kind, second, int>>(sys_seconds{42s}).relative().common() == 42 * s);
 // clang-format on
 
 

test/unit_test/static/quantity_point_test.cpp

@@ -36,6 +36,7 @@ using namespace units;
 using namespace physical::si;
 using namespace unit_constants;
 using namespace std::chrono_literals;
+using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
 
 // class invariants
 
@@ -66,7 +67,9 @@ static_assert(quantity_point(1).relative() == quantity(1));
 static_assert(!std::is_convertible_v<int, quantity_point<dim_one, one, int>>);
 
 static_assert(quantity_point(42s).relative() == 42 * s);
+static_assert(quantity_point(sys_seconds{42s}).relative() == 42 * s);
 static_assert(!std::is_convertible_v<std::chrono::seconds, quantity_point<dim_time, second, std::chrono::seconds::rep>>);
+static_assert(!std::is_convertible_v<sys_seconds, quantity_point<dim_time, second, sys_seconds::rep>>);
 
 static_assert(quantity_point<dim_length, metre, int>().relative() == 0_q_m);
 constexpr quantity_point<dim_length, metre, int> km{1000_q_m};