roland/xo-alloc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-unit: refactor: rename dim -> dimension (but provide typealias)

Browse source
This commit is contained in:
Roland Conybeare 2024-05-07 13:36:36 -04:00
commit ee083cda00
4 changed files with 36 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

7
include/xo/unit/basis_unit.hpp
View file

@ -16,12 +16,13 @@ namespace xo {
struct basis_unit {
public:
constexpr basis_unit() = default;
constexpr basis_unit(dim native_dim, const scalefactor_ratio_type & scalefactor)
constexpr basis_unit(dimension native_dim,
const scalefactor_ratio_type & scalefactor)
: native_dim_{native_dim},
scalefactor_{scalefactor}
{}
constexpr dim native_dim() const { return native_dim_; }
constexpr dimension native_dim() const { return native_dim_; }
constexpr const scalefactor_ratio_type & scalefactor() const { return scalefactor_; }
constexpr basis_unit2_abbrev_type abbrev() const {
@ -33,7 +34,7 @@ namespace xo {
public: /* need public members so that a basis_unit instance can be a non-type template parameter (a structural type) */
/** @brief identifies a native unit, e.g. time (in seconds) **/
dim native_dim_ = dim::invalid;
dimension native_dim_ = dimension::invalid;
/** @brief this unit defined as multiple scalefactor times native unit **/
scalefactor_ratio_type scalefactor_;
};

28
include/xo/unit/basis_unit_abbrev.hpp
View file

@ -18,7 +18,7 @@ namespace xo {
static
constexpr basis_unit2_abbrev_type
fallback_unit_abbrev(const scalefactor_ratio_type & scalefactor,
dim native_dim)
dimension native_dim)
{
/* e.g. unit of '1000 grams' will have abbrev '1000g' in absence
* of a specialization for scaled_native_unit_abbrev
@ -65,7 +65,7 @@ namespace xo {
}
}
return fallback_unit_abbrev(scalefactor, dim::mass);
return fallback_unit_abbrev(scalefactor, dimension::mass);
}
// ----- units for dim::distance -----
@ -104,7 +104,7 @@ namespace xo {
}
}
return fallback_unit_abbrev(scalefactor, dim::distance);
return fallback_unit_abbrev(scalefactor, dimension::distance);
}
// ----- units for dim::time -----
@ -151,7 +151,7 @@ namespace xo {
}
}
return fallback_unit_abbrev(scalefactor, dim::time);
return fallback_unit_abbrev(scalefactor, dimension::time);
}
// ----- units for dim::currency -----
@ -166,7 +166,7 @@ namespace xo {
}
}
return fallback_unit_abbrev(scalefactor, dim::currency);
return fallback_unit_abbrev(scalefactor, dimension::currency);
}
// ----- units for dim::price -----
@ -181,29 +181,29 @@ namespace xo {
}
}
return fallback_unit_abbrev(scalefactor, dim::price);
return fallback_unit_abbrev(scalefactor, dimension::price);
}
// ----- basis_unit2_abbrev -----
static
constexpr basis_unit2_abbrev_type
basis_unit2_abbrev(dim native_dim,
basis_unit2_abbrev(dimension native_dim,
const scalefactor_ratio_type & scalefactor)
{
switch(native_dim) {
case dim::mass:
case dimension::mass:
return mass_unit2_abbrev(scalefactor);
case dim::distance:
case dimension::distance:
return distance_unit2_abbrev(scalefactor);
case dim::time:
case dimension::time:
return time_unit2_abbrev(scalefactor);
case dim::currency:
case dimension::currency:
return currency_unit2_abbrev(scalefactor);
case dim::price:
case dimension::price:
return price_unit2_abbrev(scalefactor);
case dim::invalid:
case dim::n_dim:
case dimension::invalid:
case dimension::n_dim:
return basis_unit2_abbrev_type();
break;
}

18
include/xo/unit/dimension.hpp
View file

@ -6,7 +6,7 @@
namespace xo {
namespace qty {
enum class dim {
enum class dimension {
invalid = -1,
/** weight. native unit = 1 gram **/
@ -29,21 +29,23 @@ namespace xo {
n_dim
};
using dim = dimension;
inline const char *
dim2str(dim x)
dim2str(dimension x)
{
switch(x) {
case dim::mass: return "mass";
case dim::distance: return "distance";
case dim::time: return "time";
case dim::currency: return "currency";
case dim::price: return "price";
case dimension::mass: return "mass";
case dimension::distance: return "distance";
case dimension::time: return "time";
case dimension::currency: return "currency";
case dimension::price: return "price";
default: break;
}
return "?dim";
}
static constexpr std::size_t n_dim = static_cast<std::size_t>(dim::n_dim);
static constexpr std::size_t n_dim = static_cast<std::size_t>(dimension::n_dim);
} /*namespace qty*/
} /*namespace xo*/

16
include/xo/unit/native_unit.hpp
View file

@ -21,26 +21,26 @@ namespace xo {
**/
struct native_unit {
public:
constexpr native_unit(dim native_dim,
constexpr native_unit(dimension native_dim,
const native_unit2_abbrev_type & abbrev_str)
: native_dim_{native_dim},
abbrev_str_{abbrev_str}
{}
constexpr dim native_dim() const { return native_dim_; }
constexpr dimension native_dim() const { return native_dim_; }
constexpr const native_unit2_abbrev_type & abbrev_str() const { return abbrev_str_; }
private:
dim native_dim_;
dimension native_dim_;
native_unit2_abbrev_type abbrev_str_;
};
static constexpr native_unit native_unit2_v[n_dim] = {
native_unit(dim::mass, native_unit2_abbrev_type::from_chars("g")),
native_unit(dim::distance, native_unit2_abbrev_type::from_chars("m")),
native_unit(dim::time, native_unit2_abbrev_type::from_chars("s")),
native_unit(dim::currency, native_unit2_abbrev_type::from_chars("ccy")),
native_unit(dim::price, native_unit2_abbrev_type::from_chars("px")),
native_unit(dimension::mass, native_unit2_abbrev_type::from_chars("g")),
native_unit(dimension::distance, native_unit2_abbrev_type::from_chars("m")),
native_unit(dimension::time, native_unit2_abbrev_type::from_chars("s")),
native_unit(dimension::currency, native_unit2_abbrev_type::from_chars("ccy")),
native_unit(dimension::price, native_unit2_abbrev_type::from_chars("px")),
};
} /*namespace qty*/