mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-31 19:04:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: derived_quantity refactored to child_quantity

Browse Source
This commit is contained in:
Mateusz Pusz
2024-10-15 21:06:52 +02:00
parent 3eecdf3946
commit 21784b125e
1 changed files with 28 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
test/static/quantity_test.cpp
View File

@@ -315,50 +315,51 @@ static_assert(invalid_getter_with_unit_conversion<quantity>);
// derived quantities // derived quantities
/////////////////////////////////////// ///////////////////////////////////////
template<Representation Rep, Quantity Q, const basic_fixed_string additional_nttp_argument> template<Reference auto R, basic_fixed_string additional_nttp_argument,
struct derived_quantity : quantity<Q::reference, Rep> { RepresentationOf<get_quantity_spec(R).character> Rep = double>
static constexpr auto reference = Q::reference; struct child_quantity : quantity<R, Rep> {
static constexpr auto quantity_spec = Q::quantity_spec; using quantity_type = quantity<R, Rep>;
static constexpr auto dimension = Q::dimension; static constexpr auto reference = R;
static constexpr auto unit = Q::unit; static constexpr auto quantity_spec = quantity_type::quantity_spec;
static constexpr auto dimension = quantity_type::dimension;
static constexpr auto unit = quantity_type::unit;
using rep = Rep; using rep = Rep;
using R = quantity<reference, Rep>;
derived_quantity() = default; child_quantity() = default;
// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(const R& t) : R(t) {} constexpr explicit(false) child_quantity(const quantity_type& t) : quantity_type(t) {}
// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(R&& t) : R(std::move(t)) {} constexpr explicit(false) child_quantity(quantity_type&& t) : quantity_type(std::move(t)) {}
constexpr derived_quantity& operator=(const R& t) constexpr child_quantity& operator=(const quantity_type& q)
{ {
R::operator=(t); quantity_type::operator=(q);
return *this; return *this;
} }
constexpr derived_quantity& operator=(R&& t) constexpr child_quantity& operator=(quantity_type&& q)
{ {
R::operator=(std::move(t)); quantity_type::operator=(std::move(q));
return *this; return *this;
} }
// NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(false) operator R&() & noexcept { return *this; } constexpr explicit(false) operator quantity_type&() & noexcept { return *this; }
constexpr explicit(false) operator const R&() const& noexcept { return *this; } constexpr explicit(false) operator const quantity_type&() const& noexcept { return *this; }
constexpr explicit(false) operator R&&() && noexcept { return *this; } constexpr explicit(false) operator quantity_type&&() && noexcept { return *this; }
constexpr explicit(false) operator const R&&() const&& noexcept { return *this; } constexpr explicit(false) operator const quantity_type&&() const&& noexcept { return *this; }
// NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions)
}; };
static_assert(Quantity<derived_quantity<double, quantity<isq::length[m]>, "NTTP type description">>); static_assert(Quantity<child_quantity<isq::length[m], "NTTP type description">>);
constexpr QuantityOf<isq::length> auto get_length_derived_quantity() noexcept constexpr QuantityOf<isq::length> auto get_length_child_quantity() noexcept
{ {
derived_quantity<double, quantity<isq::length[m]>, "NTTP type description"> dist{}; child_quantity<isq::length[m], "NTTP type description"> dist{};
dist += 1 * m; dist += 1 * m;
dist = dist + 1 * m; dist = dist + 1 * m;
dist *= 0.5; dist *= 0.5;
return dist; return dist;
} }
static_assert(get_length_derived_quantity() == 1 * m); static_assert(get_length_child_quantity() == 1 * m);
///////// /////////
@@ -806,6 +807,11 @@ static_assert(is_same_v<decltype(isq::energy(1 * kg * m2 / s2) -
(isq::mass(1 * kg) * pow<2>(isq::length(1 * m) / isq::time(1 * s))).in(J)), (isq::mass(1 * kg) * pow<2>(isq::length(1 * m) / isq::time(1 * s))).in(J)),
quantity<isq::energy[J], int>>); quantity<isq::energy[J], int>>);
static_assert(is_of_type<child_quantity<si::metre, "L">(1. * m) + 1 * m, quantity<si::metre>>);
static_assert(is_of_type<1 * m + child_quantity<si::metre, "L">(1. * m), quantity<si::metre>>);
static_assert(is_of_type<child_quantity<si::metre, "L">(1. * m) - 1 * m, quantity<si::metre>>);
static_assert(is_of_type<1 * m - child_quantity<si::metre, "L">(1. * m), quantity<si::metre>>);
// Different named dimensions // Different named dimensions
template<typename... Ts> template<typename... Ts>
consteval bool invalid_arithmetic(Ts... ts) consteval bool invalid_arithmetic(Ts... ts)