feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

[msvc][fix] update changes for master

Browse Source
This commit is contained in:
Jonas Hoppe
2024-09-03 11:27:44 +02:00
parent 4b61716bb4
commit 4d715734bf
11 changed files with 36 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/include/mp-units/bits/get_associated_quantity.h
View File

@@ -76,9 +76,9 @@ template<AssociatedUnit U>
template<AssociatedUnit U>
[[nodiscard]] consteval auto get_associated_quantity(U u)
{
constexpr bool all_kinds = all_are_kinds(u);
constexpr bool all_kinds = all_are_kinds(U{});
if constexpr (all_kinds)
return kind_of<get_associated_quantity_impl(u)>;
return kind_of<get_associated_quantity_impl(U{})>;
else
return get_associated_quantity_impl(u);
}

4
src/core/include/mp-units/framework/construction_helpers.h
View File

@@ -41,7 +41,7 @@ template<Reference R>
struct delta_ {
template<typename Rep>
requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
[[nodiscard]] constexpr quantity<R{}, std::remove_cvref_t<Rep>> operator()(Rep&& lhs) const
[[nodiscard]] constexpr quantity<(R{}), std::remove_cvref_t<Rep>> operator()(Rep&& lhs) const
{
return quantity{std::forward<Rep>(lhs), R{}};
}
@@ -51,7 +51,7 @@ template<Reference R>
struct absolute_ {
template<typename Rep>
requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
[[nodiscard]] constexpr quantity_point<R{}, default_point_origin(R{}), std::remove_cvref_t<Rep>> operator()(
[[nodiscard]] constexpr quantity_point<(R{}), default_point_origin(R{}), std::remove_cvref_t<Rep>> operator()(
Rep&& lhs) const
{
return quantity_point{quantity{std::forward<Rep>(lhs), R{}}};

2
src/core/include/mp-units/framework/magnitude.h
View File

@@ -708,7 +708,7 @@ void to_base_specialization_of_magnitude(const volatile magnitude<Ms...>*);
template<typename T>
inline constexpr bool is_derived_from_specialization_of_magnitude =
requires(T* t) { to_base_specialization_of_magnitude(t); };
requires(T* type) { to_base_specialization_of_magnitude(type); };
template<typename T>
requires is_derived_from_specialization_of_magnitude<T>

14
src/core/include/mp-units/framework/quantity_point.h
View File

@@ -54,14 +54,14 @@ template<PointOrigin PO>
struct point_origin_interface {
template<PointOrigin PO, Quantity Q>
requires ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO::quantity_spec>
[[nodiscard]] friend constexpr quantity_point<Q::reference, PO{}, typename Q::rep> operator+(PO, Q&& q)
[[nodiscard]] friend constexpr quantity_point<Q::reference, (PO{}), typename Q::rep> operator+(PO, Q&& q)
{
return quantity_point{std::forward<Q>(q), PO{}};
}
template<Quantity Q, PointOrigin PO>
requires ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO::quantity_spec>
[[nodiscard]] friend constexpr quantity_point<Q::reference, PO{}, typename Q::rep> operator+(Q&& q, PO po)
[[nodiscard]] friend constexpr quantity_point<Q::reference, (PO{}), typename Q::rep> operator+(Q&& q, PO po)
{
return po + std::forward<Q>(q);
}
@@ -336,35 +336,35 @@ public:
requires detail::QuantityConvertibleTo<quantity_type, quantity<reference, ToRep>>
[[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto in() const
{
return ::mp_units::quantity_point{quantity_ref_from(PO).template in<ToRep>(), PO};
return ::mp_units::quantity_point{quantity_ref_from(point_origin).template in<ToRep>(), point_origin};
}
template<RepresentationOf<quantity_spec.character> ToRep, detail::UnitCompatibleWith<unit, quantity_spec> ToU>
requires detail::QuantityConvertibleTo<quantity_type, quantity<detail::make_reference(quantity_spec, ToU{}), ToRep>>
[[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto in(ToU) const
{
return ::mp_units::quantity_point{quantity_ref_from(PO).template in<ToRep>(ToU{}), PO};
return ::mp_units::quantity_point{quantity_ref_from(point_origin).template in<ToRep>(ToU{}), point_origin};
}
template<detail::UnitCompatibleWith<unit, quantity_spec> ToU>
requires requires(quantity_type q) { value_cast<ToU{}>(q); }
[[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in(ToU) const
{
return ::mp_units::quantity_point{quantity_ref_from(point_origin).force_in(ToU{}), PO};
return ::mp_units::quantity_point{quantity_ref_from(point_origin).force_in(ToU{}), point_origin};
}
template<RepresentationOf<quantity_spec.character> ToRep>
requires requires(quantity_type q) { value_cast<ToRep>(q); }
[[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in() const
{
return ::mp_units::quantity_point{quantity_ref_from(PO).template force_in<ToRep>(), PO};
return ::mp_units::quantity_point{quantity_ref_from(point_origin).template force_in<ToRep>(), point_origin};
}
template<RepresentationOf<quantity_spec.character> ToRep, detail::UnitCompatibleWith<unit, quantity_spec> ToU>
requires requires(quantity_type q) { value_cast<ToU{}, ToRep>(q); }
[[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in(ToU) const
{
return ::mp_units::quantity_point{quantity_ref_from(PO).template force_in<ToRep>(ToU{}), point_origin};
return ::mp_units::quantity_point{quantity_ref_from(point_origin).template force_in<ToRep>(ToU{}), point_origin};
}
// conversion operators

8
src/core/include/mp-units/framework/quantity_spec.h
View File

@@ -673,9 +673,9 @@ template<QuantitySpec Q>
template<Dimension D1, Dimension D2>
[[nodiscard]] consteval bool ingredients_dimension_less(D1 lhs, D2 rhs)
{
if constexpr (lhs == rhs || lhs == dimension_one)
if constexpr (D1{} == D2{} || D1{} == dimension_one)
return false;
else if constexpr (rhs == dimension_one)
else if constexpr (D2{} == dimension_one)
return true;
else
return detail::type_name<D1>() < detail::type_name<D2>();
@@ -1496,9 +1496,9 @@ template<QuantitySpec Q>
MP_UNITS_EXPORT_BEGIN
template<QuantitySpec Q>
[[nodiscard]] consteval detail::QuantityKindSpec auto get_kind(Q)
[[nodiscard]] consteval detail::QuantityKindSpec auto get_kind(Q q)
{
return kind_of<detail::get_kind_tree_root(Q{})>;
return kind_of<detail::get_kind_tree_root(decltype(q){})>;
}
[[nodiscard]] consteval QuantitySpec auto common_quantity_spec(QuantitySpec auto q) { return q; }

4
src/core/include/mp-units/framework/reference.h
View File

@@ -288,9 +288,9 @@ template<Reference R1, Reference R2, Reference... Rest>
} -> Unit;
}
{
return detail::reference_t<common_quantity_spec(get_quantity_spec(r1), get_quantity_spec(r2),
return detail::reference_t<common_quantity_spec(get_quantity_spec(R1{}), get_quantity_spec(R2{}),
get_quantity_spec(rest)...),
common_unit(get_unit(r1), get_unit(r2), get_unit(rest)...)>{};
common_unit(get_unit(R1{}), get_unit(R2{}), get_unit(rest)...)>{};
}
MP_UNITS_EXPORT_END

2
src/core/include/mp-units/framework/unit.h
View File

@@ -633,7 +633,7 @@ template<Unit From, Unit To>
template<Unit U1, Unit U2>
[[nodiscard]] consteval Unit auto common_unit(U1 u1, U2 u2)
requires(convertible(u1, u2))
requires(convertible(U1{}, U2{}))
{
if constexpr (is_same_v<U1, U2>)
return u1;

12
test/static/chrono_test.cpp
View File

@@ -107,13 +107,13 @@ static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
// conversion to chrono
static_assert(
std::constructible_from<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
static_assert(std::convertible_to<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(std::constructible_from<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
static_assert(std::convertible_to<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
std::constructible_from<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
static_assert(std::convertible_to<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(std::constructible_from<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
static_assert(std::convertible_to<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
static_assert(
std::constructible_from<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
static_assert(std::convertible_to<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
std::constructible_from<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
static_assert(std::convertible_to<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
// units mapping
static_assert(quantity{1ns} == 1 * ns);

25
test/static/concepts_test.cpp
View File

@@ -155,31 +155,6 @@ static_assert(!Unit<int>);
static_assert(!Unit<std::chrono::seconds>);
#endif
// NamedUnit
static_assert(detail::NamedUnit<struct si::metre>);
static_assert(detail::NamedUnit<struct natural::electronvolt>);
static_assert(!detail::NamedUnit<decltype(si::kilogram)>);
static_assert(!detail::NamedUnit<decltype((si::kilo<(si::gram)>))>);
static_assert(!detail::NamedUnit<decltype(si::metre / si::second)>);
static_assert(!detail::NamedUnit<decltype(inverse(si::second))>);
static_assert(!detail::NamedUnit<decltype(mag<10> * si::second)>);
static_assert(!detail::NamedUnit<decltype(square(si::metre))>);
static_assert(!detail::NamedUnit<decltype(pow<2>(si::metre))>);
static_assert(detail::NamedUnit<struct si::standard_gravity>);
static_assert(!detail::NamedUnit<scaled_unit<mag<10>, struct si::second>>);
static_assert(!detail::NamedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
static_assert(!detail::NamedUnit<struct one>);
static_assert(!detail::NamedUnit<named_unit<"?", kind_of<(isq::length)>>>);
static_assert(!detail::NamedUnit<named_unit<"?">>);
static_assert(!detail::NamedUnit<named_unit<"?", si::metre / si::second>>);
static_assert(!detail::NamedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
static_assert(!detail::NamedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
static_assert(!detail::NamedUnit<struct isq::dim_length>);
static_assert(!detail::NamedUnit<int>);
#if MP_UNITS_HOSTED
static_assert(!detail::NamedUnit<std::chrono::seconds>);
#endif
// PrefixableUnit
static_assert(PrefixableUnit<struct si::metre>);
static_assert(PrefixableUnit<struct natural::electronvolt>);

10
test/static/quantity_point_test.cpp
View File

@@ -1131,12 +1131,12 @@ concept invalid_binary_operations = requires {
requires !requires { Origin - Origin; };
// unit constants
requires !requires { QP<si::metre, mean_sea_level, int>(1) + m; };
requires !requires { QP<si::metre, mean_sea_level, int>(1) - m; };
requires !requires { QP<(si::metre), mean_sea_level, int>(1) + m; };
requires !requires { QP<(si::metre), mean_sea_level, int>(1) - m; };
requires !requires { Origin + m; };
requires !requires { Origin - m; };
requires !requires { m + QP<si::metre, mean_sea_level, int>(1); };
requires !requires { m - QP<si::metre, mean_sea_level, int>(1); };
requires !requires { m + QP<(si::metre), mean_sea_level, int>(1); };
requires !requires { m - QP<(si::metre), mean_sea_level, int>(1); };
requires !requires { m + Origin; };
requires !requires { m - Origin; };
};
@@ -1717,7 +1717,7 @@ static_assert(value_cast<m>(quantity_point{2 * km}).quantity_from_zero().numeric
static_assert(value_cast<km>(quantity_point{2000 * m}).quantity_from_zero().numerical_value_in(km) == 2);
static_assert(value_cast<int>(quantity_point{1.23 * m}).quantity_from_zero().numerical_value_in(m) == 1);
static_assert(
value_cast<km / h>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
value_cast<(km / h)>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
// lvalue references in value_cast
namespace lvalue_tests {
constexpr quantity_point lvalue_qp{2 * km};

12
test/static/quantity_test.cpp
View File

@@ -215,16 +215,16 @@ static_assert(quantity<isq::length[km]>(1500 * m).numerical_value_in(km) == 1.5)
static_assert(!std::convertible_to<quantity<one>, double>);
static_assert(std::constructible_from<double, quantity<one>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, double>);
static_assert(std::constructible_from<double, quantity<isq::angular_measure[one]>>);
static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, double>);
static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one])>>);
static_assert(!std::convertible_to<quantity<one>, int>);
static_assert(std::constructible_from<int, quantity<one>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, int>);
static_assert(std::constructible_from<int, quantity<isq::angular_measure[one]>>);
static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, int>);
static_assert(std::constructible_from<int, quantity<(isq::angular_measure[one])>>);
static_assert(!std::convertible_to<quantity<one, int>, double>);
static_assert(std::constructible_from<double, quantity<one, int>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one], int>, double>);
static_assert(std::constructible_from<double, quantity<isq::angular_measure[one], int>>);
static_assert(!std::convertible_to<quantity<(isq::angular_measure[one]), int>, double>);
static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one]), int>>);
///////////////////////////////////