From 6508fd5dc2cb50e70d6e806978b1e5cb36217f3c Mon Sep 17 00:00:00 2001 From: Roland Conybeare Date: Thu, 2 May 2024 14:12:03 -0400 Subject: [PATCH] xo-unit: refactor: rename quantity2_concept -> quantity_concept --- include/xo/unit/quantity2_concept.hpp | 2 +- include/xo/unit/quantity_ops.hpp | 10 ++-- include/xo/unit/xquantity.hpp | 26 +++++----- utest/quantity.test.cpp | 68 +++++++++++++-------------- 4 files changed, 53 insertions(+), 53 deletions(-) diff --git a/include/xo/unit/quantity2_concept.hpp b/include/xo/unit/quantity2_concept.hpp index 9d6c3922..56e0d260 100644 --- a/include/xo/unit/quantity2_concept.hpp +++ b/include/xo/unit/quantity2_concept.hpp @@ -8,7 +8,7 @@ namespace xo { namespace qty { template - concept quantity2_concept = requires(Quantity qty, typename Quantity::repr_type repr) + concept quantity_concept = requires(Quantity qty, typename Quantity::repr_type repr) { typename Quantity::unit_type; typename Quantity::repr_type; diff --git a/include/xo/unit/quantity_ops.hpp b/include/xo/unit/quantity_ops.hpp index 5b4513bb..25815bbb 100644 --- a/include/xo/unit/quantity_ops.hpp +++ b/include/xo/unit/quantity_ops.hpp @@ -13,7 +13,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator* (const Quantity & x, const Quantity2 & y) { @@ -22,7 +22,7 @@ namespace xo { /** note: does not require unit scaling, so constexpr with c++23 **/ template - requires std::is_arithmetic_v && quantity2_concept + requires std::is_arithmetic_v && quantity_concept constexpr auto operator* (Dimensionless x, const Quantity & y) { @@ -31,7 +31,7 @@ namespace xo { /** note: does not require unit scaling, so constexpr with c++23 **/ template - requires std::is_arithmetic_v && quantity2_concept + requires std::is_arithmetic_v && quantity_concept constexpr auto operator* (const Quantity & x, Dimensionless y) { @@ -41,7 +41,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator== (const Quantity & x, const Quantity2 & y) { @@ -51,7 +51,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator<=> (const Quantity & x, const Quantity2 & y) { diff --git a/include/xo/unit/xquantity.hpp b/include/xo/unit/xquantity.hpp index 75edf2e9..3d3bc6e3 100644 --- a/include/xo/unit/xquantity.hpp +++ b/include/xo/unit/xquantity.hpp @@ -246,7 +246,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator/ (const Quantity & x, const Quantity2 & y) { @@ -255,7 +255,7 @@ namespace xo { /** note: doesn not require unit scaling, so constexpr with c++23 **/ template - requires quantity2_concept && std::is_arithmetic_v + requires quantity_concept && std::is_arithmetic_v constexpr auto operator/ (const Quantity & x, Dimensionless y) { @@ -264,7 +264,7 @@ namespace xo { /** note: doesn not require unit scaling, so constexpr with c++23 **/ template - requires std::is_arithmetic_v && quantity2_concept + requires std::is_arithmetic_v && quantity_concept constexpr auto operator/ (Dimensionless x, const Quantity & y) { @@ -274,7 +274,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator+ (const Quantity & x, const Quantity2 & y) { @@ -284,7 +284,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator+ (const Quantity & x, double y) { @@ -294,7 +294,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator+ (double x, const Quantity & y) { @@ -304,7 +304,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept && quantity2_concept + requires quantity_concept && quantity_concept constexpr auto operator- (const Quantity & x, const Quantity2 & y) { @@ -314,7 +314,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator- (const Quantity & x, double y) { @@ -324,7 +324,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator- (double x, const Quantity & y) { @@ -334,7 +334,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator== (const Quantity & x, double y) { @@ -344,7 +344,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator== (double x, const Quantity & y) { @@ -354,7 +354,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator<=> (const Quantity & x, double y) { @@ -364,7 +364,7 @@ namespace xo { /** note: won't have constexpr result until c++26 (when ::sqrt(), ::pow() are constexpr) **/ template - requires quantity2_concept + requires quantity_concept constexpr auto operator<=> (double x, const Quantity & y) { diff --git a/utest/quantity.test.cpp b/utest/quantity.test.cpp index 7104bc46..b63fa1b5 100644 --- a/utest/quantity.test.cpp +++ b/utest/quantity.test.cpp @@ -21,61 +21,61 @@ namespace xo { //log && log("(A)", xtag("foo", foo)); constexpr auto pg = qty::picograms(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(pg) == sizeof(double)); static_assert(pg.scale() == 1.0); static_assert(pg.abbrev() == flatstring("pg")); constexpr auto ng = qty::nanograms(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(ng) == sizeof(double)); static_assert(ng.scale() == 1.0); static_assert(ng.abbrev() == flatstring("ng")); constexpr auto ug = qty::micrograms(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(ug) == sizeof(double)); static_assert(ug.scale() == 1.0); static_assert(ug.abbrev() == flatstring("ug")); constexpr auto mg = qty::milligrams(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(mg) == sizeof(double)); static_assert(mg.scale() == 1.0); static_assert(mg.abbrev() == flatstring("mg")); constexpr auto g = qty::grams(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(g) == sizeof(double)); static_assert(g.scale() == 1.0); static_assert(g.abbrev() == flatstring("g")); constexpr auto kg = qty::kilograms(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(kg) == sizeof(double)); static_assert(kg.scale() == 1.0); static_assert(kg.abbrev() == flatstring("kg")); constexpr auto t = qty::tonnes(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(t) == sizeof(double)); static_assert(t.scale() == 1.0); static_assert(t.abbrev() == flatstring("t")); constexpr auto kt = qty::kilotonnes(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(kt) == sizeof(double)); static_assert(kt.scale() == 1.0); static_assert(kt.abbrev() == flatstring("kt")); constexpr auto mt = qty::megatonnes(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(mt) == sizeof(double)); static_assert(mt.scale() == 1.0); static_assert(mt.abbrev() == flatstring("Mt")); constexpr auto gt = qty::gigatonnes(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(gt) == sizeof(double)); static_assert(gt.scale() == 1.0); static_assert(gt.abbrev() == flatstring("Gt")); @@ -111,61 +111,61 @@ namespace xo { scope log(XO_DEBUG2(c_debug_flag, "TEST_CASE.quantity.distance")); constexpr auto pm = qty::picometers(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(pm) == sizeof(double)); static_assert(pm.scale() == 1.0); static_assert(pm.abbrev() == flatstring("pm")); constexpr auto nm = qty::nanometers(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(nm) == sizeof(double)); static_assert(nm.scale() == 1.0); static_assert(nm.abbrev() == flatstring("nm")); constexpr auto um = qty::micrometers(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(um) == sizeof(double)); static_assert(um.scale() == 1.0); static_assert(um.abbrev() == flatstring("um")); constexpr auto mm = qty::millimeters(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(mm) == sizeof(double)); static_assert(mm.scale() == 1.0); static_assert(mm.abbrev() == flatstring("mm")); constexpr auto m = qty::meters(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(m) == sizeof(double)); static_assert(m.scale() == 1.0); static_assert(m.abbrev() == flatstring("m")); constexpr auto km = qty::kilometers(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(km) == sizeof(double)); static_assert(km.scale() == 1.0); static_assert(km.abbrev() == flatstring("km")); constexpr auto Mm = qty::megameters(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(Mm) == sizeof(double)); static_assert(Mm.scale() == 1.0); static_assert(Mm.abbrev() == flatstring("Mm")); constexpr auto Gm = qty::gigameters(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(Gm) == sizeof(double)); static_assert(Gm.scale() == 1.0); static_assert(Gm.abbrev() == flatstring("Gm")); constexpr auto lsec = qty::lightseconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(lsec) == sizeof(double)); static_assert(lsec.scale() == 1.0); static_assert(lsec.abbrev() == flatstring("lsec")); constexpr auto AU = qty::astronomicalunits(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(AU) == sizeof(double)); static_assert(AU.scale() == 1.0); static_assert(AU.abbrev() == flatstring("AU")); @@ -200,85 +200,85 @@ namespace xo { scope log(XO_DEBUG2(c_debug_flag, "TEST_CASE.quantity.time")); constexpr auto ps = qty::picoseconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(ps) == sizeof(double)); static_assert(ps.scale() == 1.0); static_assert(ps.abbrev() == flatstring("ps")); constexpr auto ns = qty::nanoseconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(ns) == sizeof(double)); static_assert(ns.scale() == 1.0); static_assert(ns.abbrev() == flatstring("ns")); constexpr auto us = qty::microseconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(us) == sizeof(double)); static_assert(us.scale() == 1.0); static_assert(us.abbrev() == flatstring("us")); constexpr auto ms = qty::milliseconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(ms) == sizeof(double)); static_assert(ms.scale() == 1.0); static_assert(ms.abbrev() == flatstring("ms")); constexpr auto s = qty::seconds(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(s) == sizeof(double)); static_assert(s.scale() == 1.0); static_assert(s.abbrev() == flatstring("s")); constexpr auto min = qty::minutes(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(min) == sizeof(double)); static_assert(min.scale() == 1.0); static_assert(min.abbrev() == flatstring("min")); constexpr auto hr = qty::hours(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(hr) == sizeof(double)); static_assert(hr.scale() == 1.0); static_assert(hr.abbrev() == flatstring("hr")); constexpr auto dy = qty::days(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(dy) == sizeof(double)); static_assert(dy.scale() == 1.0); static_assert(dy.abbrev() == flatstring("dy")); constexpr auto wk = qty::weeks(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(wk) == sizeof(double)); static_assert(wk.scale() == 1.0); static_assert(wk.abbrev() == flatstring("wk")); constexpr auto mo = qty::months(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(mo) == sizeof(double)); static_assert(mo.scale() == 1.0); static_assert(mo.abbrev() == flatstring("mo")); constexpr auto yr = qty::years(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(yr) == sizeof(double)); static_assert(yr.scale() == 1.0); static_assert(yr.abbrev() == flatstring("yr")); constexpr auto yr250 = qty::year250s(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(yr250) == sizeof(double)); static_assert(yr250.scale() == 1.0); static_assert(yr250.abbrev() == flatstring("yr250")); constexpr auto yr360 = qty::year360s(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(yr360) == sizeof(double)); static_assert(yr360.scale() == 1.0); static_assert(yr360.abbrev() == flatstring("yr360")); constexpr auto yr365 = qty::year365s(1.0); - static_assert(quantity2_concept); + static_assert(quantity_concept); static_assert(sizeof(yr365) == sizeof(double)); static_assert(yr365.scale() == 1.0); static_assert(yr365.abbrev() == flatstring("yr365"));