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

style: clang-format-16 applied to all the code base

Browse Source
This commit is contained in:
Mateusz Pusz
2023-03-29 17:05:02 +02:00
parent 60eaa4728d
commit 33d9f43b0f
17 changed files with 509 additions and 530 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/include/units/bits/basic_concepts.h
+35 -37
View File
@@ -217,14 +217,13 @@ struct point_origin;
* Satisfied by types derived from an specialization of @c point_origin.
*/
template<typename T>
concept PointOrigin = is_derived_from_specialization_of<T, point_origin> &&
requires {
typename T::dimension;
requires Dimension<typename T::dimension>;
typename T::point_origin;
requires std::same_as<typename T::point_origin, point_origin<typename T::dimension>>;
requires !std::same_as<T, point_origin<typename T::dimension>>;
};
concept PointOrigin = is_derived_from_specialization_of<T, point_origin> && requires {
typename T::dimension;
requires Dimension<typename T::dimension>;
typename T::point_origin;
requires std::same_as<typename T::point_origin, point_origin<typename T::dimension>>;
requires !std::same_as<T, point_origin<typename T::dimension>>;
};
// RebindablePointOriginFor
@@ -261,10 +260,10 @@ struct _kind_base;
template<typename T, template<typename...> typename Base>
concept kind_impl_ = is_derived_from_specialization_of<T, Base> && requires {
typename T::base_kind;
typename T::dimension;
requires Dimension<typename T::dimension>;
};
typename T::base_kind;
typename T::dimension;
requires Dimension<typename T::dimension>;
};
/**
* @brief A concept matching all kind types
@@ -389,12 +388,12 @@ concept QuantityPointLike = detail::is_quantity_point_like<T>;
template<typename T, typename U>
concept common_type_with_ = // exposition only
(std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>) &&
(std::constructible_from<std::common_type_t<T, U>, T>) && (std::constructible_from<std::common_type_t<T, U>, U>);
(std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>)&&(
std::constructible_from<std::common_type_t<T, U>, T>)&&(std::constructible_from<std::common_type_t<T, U>, U>);
template<typename T, typename U = T>
concept scalable_number_ = // exposition only
(std::regular_invocable<std::multiplies<>, T, U>) && (std::regular_invocable<std::divides<>, T, U>);
(std::regular_invocable<std::multiplies<>, T, U>)&&(std::regular_invocable<std::divides<>, T, U>);
template<typename T>
concept castable_number_ = // exposition only
@@ -443,37 +442,36 @@ concept wrapped_quantity_ = // exposition only
* Satisfied by types that satisfy `(!Quantity<T>) && (!WrappedQuantity<T>) && std::regular<T>`.
*/
template<typename T>
concept Representation = (!Quantity<T>) && (!QuantityLike<T>) &&
(!wrapped_quantity_<T>) && std::regular<T> && scalable_<T>;
concept Representation = (!Quantity<T>)&&(!QuantityLike<T>)&&(!wrapped_quantity_<T>)&&std::regular<T> && scalable_<T>;
namespace detail {
template<typename T>
requires requires(T q) {
typename quantity_like_traits<T>::dimension;
typename quantity_like_traits<T>::unit;
typename quantity_like_traits<T>::rep;
requires Dimension<typename quantity_like_traits<T>::dimension>;
requires Unit<typename quantity_like_traits<T>::unit>;
requires Representation<typename quantity_like_traits<T>::rep>;
{
quantity_like_traits<T>::number(q)
} -> std::convertible_to<typename quantity_like_traits<T>::rep>;
}
typename quantity_like_traits<T>::dimension;
typename quantity_like_traits<T>::unit;
typename quantity_like_traits<T>::rep;
requires Dimension<typename quantity_like_traits<T>::dimension>;
requires Unit<typename quantity_like_traits<T>::unit>;
requires Representation<typename quantity_like_traits<T>::rep>;
{
quantity_like_traits<T>::number(q)
} -> std::convertible_to<typename quantity_like_traits<T>::rep>;
}
inline constexpr bool is_quantity_like<T> = true;
template<typename T>
requires requires(T q) {
typename quantity_point_like_traits<T>::dimension;
typename quantity_point_like_traits<T>::unit;
typename quantity_point_like_traits<T>::rep;
requires Dimension<typename quantity_point_like_traits<T>::dimension>;
requires Unit<typename quantity_point_like_traits<T>::unit>;
requires Representation<typename quantity_point_like_traits<T>::rep>;
{
quantity_point_like_traits<T>::relative(q)
} -> QuantityLike;
}
typename quantity_point_like_traits<T>::dimension;
typename quantity_point_like_traits<T>::unit;
typename quantity_point_like_traits<T>::rep;
requires Dimension<typename quantity_point_like_traits<T>::dimension>;
requires Unit<typename quantity_point_like_traits<T>::unit>;
requires Representation<typename quantity_point_like_traits<T>::rep>;
{
quantity_point_like_traits<T>::relative(q)
} -> QuantityLike;
}
inline constexpr bool is_quantity_point_like<T> = true;
} // namespace detail
src/core/include/units/customization_points.h
+8 -8
View File
@@ -69,20 +69,20 @@ struct quantity_values {
static constexpr Rep min() noexcept
requires requires {
{
std::numeric_limits<Rep>::lowest()
} -> std::same_as<Rep>;
}
{
std::numeric_limits<Rep>::lowest()
} -> std::same_as<Rep>;
}
{
return std::numeric_limits<Rep>::lowest();
}
static constexpr Rep max() noexcept
requires requires {
{
std::numeric_limits<Rep>::max()
} -> std::same_as<Rep>;
}
{
std::numeric_limits<Rep>::max()
} -> std::same_as<Rep>;
}
{
return std::numeric_limits<Rep>::max();
}
src/core/include/units/magnitude.h
+2 -4
View File
@@ -313,11 +313,9 @@ struct pairwise_all {
}(sizeof...(Ts));
// Compare zero or more pairs of neighbours as needed.
return [this]<std::size_t... Is>(std::tuple<Ts...> && t, std::index_sequence<Is...>)
{
return [this]<std::size_t... Is>(std::tuple<Ts...>&& t, std::index_sequence<Is...>) {
return (predicate(std::get<Is>(t), std::get<Is + 1>(t)) && ...);
}
(std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
}(std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
}
};
src/core/include/units/math.h
+16 -18
View File
@@ -159,9 +159,9 @@ template<Unit To, typename D, typename U, typename Rep>
requires((!treat_as_floating_point<Rep>) || requires { floor(q.number()); } ||
requires { std::floor(q.number()); }) &&
(std::same_as<To, U> || requires {
::units::quantity_cast<To>(q);
quantity<D, To, Rep>::one();
})
::units::quantity_cast<To>(q);
quantity<D, To, Rep>::one();
})
{
const auto handle_signed_results = [&]<typename T>(const T& res) {
if (res > q) {
@@ -208,9 +208,9 @@ template<Unit To, typename D, typename U, typename Rep>
[[nodiscard]] constexpr quantity<D, To, Rep> ceil(const quantity<D, U, Rep>& q) noexcept
requires((!treat_as_floating_point<Rep>) || requires { ceil(q.number()); } || requires { std::ceil(q.number()); }) &&
(std::same_as<To, U> || requires {
::units::quantity_cast<To>(q);
quantity<D, To, Rep>::one();
})
::units::quantity_cast<To>(q);
quantity<D, To, Rep>::one();
})
{
const auto handle_signed_results = [&]<typename T>(const T& res) {
if (res < q) {
@@ -260,9 +260,9 @@ template<Unit To, typename D, typename U, typename Rep>
requires((!treat_as_floating_point<Rep>) || requires { round(q.number()); } ||
requires { std::round(q.number()); }) &&
(std::same_as<To, U> || requires {
::units::floor<To>(q);
quantity<D, To, Rep>::one();
})
::units::floor<To>(q);
quantity<D, To, Rep>::one();
})
{
if constexpr (std::is_same_v<To, U>) {
if constexpr (treat_as_floating_point<Rep>) {
@@ -308,10 +308,9 @@ template<Quantity To, std::same_as<typename To::dimension> D, typename U, std::s
*/
template<Quantity Q1, Quantity Q2>
[[nodiscard]] inline std::common_type_t<Q1, Q2> hypot(const Q1& x, const Q2& y) noexcept
requires requires { typename std::common_type_t<Q1, Q2>; } &&
requires(std::common_type_t<Q1, Q2> q) {
requires requires { hypot(q.number(), q.number()); } || requires { std::hypot(q.number(), q.number()); };
}
requires requires { typename std::common_type_t<Q1, Q2>; } && requires(std::common_type_t<Q1, Q2> q) {
requires requires { hypot(q.number(), q.number()); } || requires { std::hypot(q.number(), q.number()); };
}
{
using type = std::common_type_t<Q1, Q2>;
type xx = x;
@@ -326,11 +325,10 @@ template<Quantity Q1, Quantity Q2>
*/
template<Quantity Q1, Quantity Q2, Quantity Q3>
[[nodiscard]] inline std::common_type_t<Q1, Q2, Q3> hypot(const Q1& x, const Q2& y, const Q3& z) noexcept
requires requires { typename std::common_type_t<Q1, Q2, Q3>; } &&
requires(std::common_type_t<Q1, Q2, Q3> q) {
requires requires { hypot(q.number(), q.number(), q.number()); } ||
requires { std::hypot(q.number(), q.number(), q.number()); };
}
requires requires { typename std::common_type_t<Q1, Q2, Q3>; } && requires(std::common_type_t<Q1, Q2, Q3> q) {
requires requires { hypot(q.number(), q.number(), q.number()); } ||
requires { std::hypot(q.number(), q.number(), q.number()); };
}
{
using type = std::common_type_t<Q1, Q2, Q3>;
type xx = x;
src/core/include/units/quantity.h
+79 -79
View File
@@ -51,8 +51,8 @@ inline constexpr auto make_quantity = [](auto&& v) {
template<typename T>
concept quantity_one =
Quantity<T> &&
(std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>) &&
detail::equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
(std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>)&&detail::
equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
} // namespace detail
@@ -62,7 +62,7 @@ concept floating_point_ = // exposition only
template<typename From, typename To>
concept safe_convertible_to_ = // exposition only
(!Quantity<From>) && (!Quantity<To>) && std::convertible_to<From, To> &&
(!Quantity<From>)&&(!Quantity<To>)&&std::convertible_to<From, To> &&
(floating_point_<To> || (!floating_point_<From>));
// QFrom ratio is an exact multiple of QTo
@@ -84,7 +84,7 @@ concept invoke_result_convertible_to_ =
Representation<T> && quantity_value_for_<Func, U, V> && safe_convertible_to_<T, std::invoke_result_t<Func, U, V>>;
template<typename Func, typename Q, typename V>
concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>) && quantity_value_for_<Func, typename Q::rep, V>;
concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>)&&quantity_value_for_<Func, typename Q::rep, V>;
template<QuantityLike Q>
using quantity_like_type = quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
@@ -169,10 +169,10 @@ public:
// member unary operators
[[nodiscard]] constexpr Quantity auto operator+() const
requires requires(rep v) {
{
+v
} -> std::common_with<rep>;
}
{
+v
} -> std::common_with<rep>;
}
{
using ret = quantity<D, U, decltype(+number())>;
return ret(+number());
@@ -187,10 +187,10 @@ public:
constexpr quantity& operator++()
requires requires(rep v) {
{
++v
} -> std::same_as<rep&>;
}
{
++v
} -> std::same_as<rep&>;
}
{
++number_;
return *this;
@@ -198,20 +198,20 @@ public:
[[nodiscard]] constexpr quantity operator++(int)
requires requires(rep v) {
{
v++
} -> std::same_as<rep>;
}
{
v++
} -> std::same_as<rep>;
}
{
return quantity(number_++);
}
constexpr quantity& operator--()
requires requires(rep v) {
{
--v
} -> std::same_as<rep&>;
}
{
--v
} -> std::same_as<rep&>;
}
{
--number_;
return *this;
@@ -219,20 +219,20 @@ public:
[[nodiscard]] constexpr quantity operator--(int)
requires requires(rep v) {
{
v--
} -> std::same_as<rep>;
}
{
v--
} -> std::same_as<rep>;
}
{
return quantity(number_--);
}
constexpr quantity& operator+=(const quantity& q)
requires requires(rep a, rep b) {
{
a += b
} -> std::same_as<rep&>;
}
{
a += b
} -> std::same_as<rep&>;
}
{
number_ += q.number();
return *this;
@@ -240,10 +240,10 @@ public:
constexpr quantity& operator-=(const quantity& q)
requires requires(rep a, rep b) {
{
a -= b
} -> std::same_as<rep&>;
}
{
a -= b
} -> std::same_as<rep&>;
}
{
number_ -= q.number();
return *this;
@@ -252,10 +252,10 @@ public:
template<typename Rep2>
constexpr quantity& operator*=(const Rep2& rhs)
requires requires(rep a, const Rep2 b) {
{
a *= b
} -> std::same_as<rep&>;
}
{
a *= b
} -> std::same_as<rep&>;
}
{
number_ *= rhs;
return *this;
@@ -263,10 +263,10 @@ public:
template<detail::quantity_one Q>
constexpr quantity& operator*=(const Q& rhs)
requires requires(rep a, const typename Q::rep b) {
{
a *= b
} -> std::same_as<rep&>;
}
{
a *= b
} -> std::same_as<rep&>;
}
{
number_ *= rhs.number();
return *this;
@@ -275,10 +275,10 @@ public:
template<typename Rep2>
constexpr quantity& operator/=(const Rep2& rhs)
requires requires(rep a, const Rep2 b) {
{
a /= b
} -> std::same_as<rep&>;
}
{
a /= b
} -> std::same_as<rep&>;
}
{
gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
number_ /= rhs;
@@ -287,10 +287,10 @@ public:
template<detail::quantity_one Q>
constexpr quantity& operator/=(const Q& rhs)
requires requires(rep a, const typename Q::rep b) {
{
a /= b
} -> std::same_as<rep&>;
}
{
a /= b
} -> std::same_as<rep&>;
}
{
gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
number_ /= rhs.number();
@@ -300,10 +300,10 @@ public:
template<typename Rep2>
constexpr quantity& operator%=(const Rep2& rhs)
requires(!floating_point_<rep>) && (!floating_point_<Rep2>) && requires(rep a, const Rep2 b) {
{
a %= b
} -> std::same_as<rep&>;
}
{
a %= b
} -> std::same_as<rep&>;
}
{
gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
number_ %= rhs;
@@ -313,10 +313,10 @@ public:
template<detail::quantity_one Q>
constexpr quantity& operator%=(const Q& rhs)
requires(!floating_point_<rep>) && (!floating_point_<typename Q::rep>) && requires(rep a, const typename Q::rep b) {
{
a %= b
} -> std::same_as<rep&>;
}
{
a %= b
} -> std::same_as<rep&>;
}
{
gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
number_ %= rhs.number();
@@ -325,10 +325,10 @@ public:
constexpr quantity& operator%=(const quantity& q)
requires(!floating_point_<rep>) && requires(rep a, rep b) {
{
a %= b
} -> std::same_as<rep&>;
}
{
a %= b
} -> std::same_as<rep&>;
}
{
gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
number_ %= q.number();
@@ -340,20 +340,20 @@ public:
template<typename Value>
[[nodiscard]] friend constexpr Quantity auto operator+(const quantity& lhs, const Value& rhs)
requires requires { // TODO: Simplify when Clang catches up.
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>;
}
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>;
}
{
return units::quantity(lhs.number() + rhs);
}
template<typename Value>
[[nodiscard]] friend constexpr Quantity auto operator+(const Value& lhs, const quantity& rhs)
requires requires { // TODO: Simplify when Clang catches up.
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>;
}
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>;
}
{
return units::quantity(lhs + rhs.number());
}
@@ -361,20 +361,20 @@ public:
template<typename Value>
[[nodiscard]] friend constexpr Quantity auto operator-(const quantity& lhs, const Value& rhs)
requires requires { // TODO: Simplify when Clang catches up.
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>;
}
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>;
}
{
return units::quantity(lhs.number() - rhs);
}
template<typename Value>
[[nodiscard]] friend constexpr Quantity auto operator-(const Value& lhs, const quantity& rhs)
requires requires { // TODO: Simplify when Clang catches up.
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>;
}
requires !Quantity<Value>;
requires is_same_v<unit, units::one>;
requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>;
}
{
return units::quantity(lhs - rhs.number());
}
@@ -445,14 +445,14 @@ public:
// CTAD
#if !UNITS_COMP_CLANG || UNITS_COMP_CLANG > 17
template<typename D, typename U, typename Rep>
explicit(false) quantity(Rep&&)->quantity<D, U, Rep>;
explicit(false) quantity(Rep&&) -> quantity<D, U, Rep>;
#endif
template<typename D, typename U, typename Rep>
explicit(false) quantity(quantity<D, U, Rep>)->quantity<D, U, Rep>;
explicit(false) quantity(quantity<D, U, Rep>) -> quantity<D, U, Rep>;
template<Representation Rep>
explicit(false) quantity(Rep)->quantity<dim_one, one, Rep>;
explicit(false) quantity(Rep) -> quantity<dim_one, one, Rep>;
template<QuantityLike Q>
explicit quantity(Q) -> quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
src/core/include/units/quantity_cast.h
+14 -14
View File
@@ -213,10 +213,10 @@ template<Representation ToRep, typename D, typename U, scalable_with_<ToRep> Rep
template<typename CastSpec, typename O, typename U, typename Rep>
[[nodiscard]] constexpr auto quantity_point_cast(const quantity_point<O, U, Rep>& qp)
requires requires {
requires is_specialization_of<CastSpec, quantity_point>;
requires requires { quantity_cast<typename CastSpec::quantity_type>(qp.relative()); };
requires equivalent<O, typename CastSpec::origin>;
} || // TODO: Simplify when Clang catches up.
requires is_specialization_of<CastSpec, quantity_point>;
requires requires { quantity_cast<typename CastSpec::quantity_type>(qp.relative()); };
requires equivalent<O, typename CastSpec::origin>;
} || // TODO: Simplify when Clang catches up.
requires { quantity_cast<CastSpec>(qp.relative()); }
{
if constexpr (is_specialization_of<CastSpec, quantity_point>)
@@ -268,12 +268,12 @@ template<Dimension ToD, Unit ToU, typename O, typename U, typename Rep>
template<typename CastSpec, typename K, typename U, typename Rep>
[[nodiscard]] constexpr QuantityKind auto quantity_kind_cast(const quantity_kind<K, U, Rep>& qk)
requires requires {
requires is_specialization_of<CastSpec, quantity_kind>;
requires requires { quantity_cast<typename CastSpec::quantity_type>(qk.common()); };
} || requires {
requires Kind<CastSpec>;
requires UnitOf<U, typename CastSpec::dimension>;
} || requires { quantity_cast<CastSpec>(qk.common()); } // TODO: Simplify when Clang catches up.
requires is_specialization_of<CastSpec, quantity_kind>;
requires requires { quantity_cast<typename CastSpec::quantity_type>(qk.common()); };
} || requires {
requires Kind<CastSpec>;
requires UnitOf<U, typename CastSpec::dimension>;
} || requires { quantity_cast<CastSpec>(qk.common()); } // TODO: Simplify when Clang catches up.
{
if constexpr (is_specialization_of<CastSpec, quantity_kind>)
return CastSpec(quantity_cast<typename CastSpec::quantity_type>(qk.common()));
@@ -331,10 +331,10 @@ template<Kind ToK, Unit ToU, typename K, typename U, typename Rep>
template<typename CastSpec, typename PK, typename U, typename Rep>
[[nodiscard]] constexpr QuantityPointKind auto quantity_point_kind_cast(const quantity_point_kind<PK, U, Rep>& qpk)
requires requires {
requires is_specialization_of<CastSpec, quantity_point_kind>;
requires requires { quantity_kind_cast<typename CastSpec::quantity_kind_type>(qpk.relative()); };
requires equivalent<typename PK::origin, typename CastSpec::point_kind_type::origin>;
} || requires { requires PointKind<CastSpec> && UnitOf<U, typename CastSpec::dimension>; } ||
requires is_specialization_of<CastSpec, quantity_point_kind>;
requires requires { quantity_kind_cast<typename CastSpec::quantity_kind_type>(qpk.relative()); };
requires equivalent<typename PK::origin, typename CastSpec::point_kind_type::origin>;
} || requires { requires PointKind<CastSpec> && UnitOf<U, typename CastSpec::dimension>; } ||
requires { quantity_kind_cast<CastSpec>(qpk.relative()); } // TODO: Simplify when Clang catches up.
{
if constexpr (is_specialization_of<CastSpec, quantity_point_kind>)
src/core/include/units/quantity_kind.h
+16 -16
View File
@@ -250,10 +250,10 @@ public:
template<Representation Value>
[[nodiscard]] friend constexpr QuantityKind auto operator*(const quantity_kind& qk, const Value& v)
requires requires(quantity_type q) {
{
q* v
} -> Quantity;
}
{
q* v
} -> Quantity;
}
{
return detail::make_quantity_kind<quantity_kind>(qk.common() * v);
}
@@ -261,10 +261,10 @@ public:
template<Representation Value>
[[nodiscard]] friend constexpr QuantityKind auto operator*(const Value& v, const quantity_kind& qk)
requires requires(quantity_type q) {
{
v* q
} -> Quantity;
}
{
v* q
} -> Quantity;
}
{
return detail::make_quantity_kind<quantity_kind>(v * qk.common());
}
@@ -272,10 +272,10 @@ public:
template<Representation Value>
[[nodiscard]] friend constexpr QuantityKind auto operator/(const quantity_kind& qk, const Value& v)
requires requires(quantity_type q) {
{
q / v
} -> Quantity;
}
{
q / v
} -> Quantity;
}
{
gsl_ExpectsAudit(v != quantity_values<Value>::zero());
return detail::make_quantity_kind<quantity_kind>(qk.common() / v);
@@ -284,10 +284,10 @@ public:
template<Representation Value>
[[nodiscard]] friend constexpr QuantityKind auto operator/(const Value& v, const quantity_kind& qk)
requires requires(quantity_type q) {
{
v / q
} -> Quantity;
}
{
v / q
} -> Quantity;
}
{
gsl_ExpectsAudit(qk.common().number() != quantity_values<rep>::zero());
return detail::downcasted_kind<quantity_kind>(v / qk.common());
src/core/include/units/symbol_text.h
+1 -1
View File
@@ -162,7 +162,7 @@ struct basic_symbol_text {
}
};
basic_symbol_text(char)->basic_symbol_text<char, 1, 1>;
basic_symbol_text(char) -> basic_symbol_text<char, 1, 1>;
template<typename StandardCharT>
basic_symbol_text(StandardCharT, char) -> basic_symbol_text<StandardCharT, 1, 1>;
src/core/include/units/unit.h
+2 -2
View File
@@ -211,7 +211,7 @@ template<typename U, typename P, typename AU>
void is_named_impl(const volatile prefixed_alias_unit<U, P, AU>*);
template<Unit U>
inline constexpr bool is_named<U> = requires(U * u) { is_named_impl(u); };
inline constexpr bool is_named<U> = requires(U* u) { is_named_impl(u); };
template<typename Child, basic_symbol_text Symbol>
void can_be_prefixed_impl(const volatile named_unit<Child, Symbol>*);
@@ -223,7 +223,7 @@ template<typename U, basic_symbol_text Symbol>
void can_be_prefixed_impl(const volatile alias_unit<U, Symbol>*);
template<Unit U>
inline constexpr bool can_be_prefixed<U> = requires(U * u) { can_be_prefixed_impl(u); };
inline constexpr bool can_be_prefixed<U> = requires(U* u) { can_be_prefixed_impl(u); };
template<Magnitude auto M, typename U>
inline constexpr bool can_be_prefixed<scaled_unit<M, U>> = can_be_prefixed<typename U::reference>;