From 6201109c60e63fd0f92029703227c64673be6912 Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Wed, 21 Jun 2023 18:07:55 +0200 Subject: [PATCH] refactor: `TYPENAME` and `CONSTEVAL` macros got `MP_UNITS_` prefix --- src/core-fmt/include/mp-units/bits/fmt.h | 2 +- src/core-fmt/include/mp-units/format.h | 2 +- .../mp-units/bits/expression_template.h | 11 +-- .../include/mp-units/bits/external/hacks.h | 8 +- .../mp-units/bits/external/type_list.h | 27 +++---- .../mp-units/bits/external/type_traits.h | 2 +- src/core/include/mp-units/bits/magnitude.h | 2 +- src/core/include/mp-units/bits/ratio.h | 10 +-- src/core/include/mp-units/bits/sudo_cast.h | 14 ++-- src/utility/include/mp-units/chrono.h | 4 +- src/utility/include/mp-units/random.h | 78 +++++++++---------- 11 files changed, 81 insertions(+), 79 deletions(-) diff --git a/src/core-fmt/include/mp-units/bits/fmt.h b/src/core-fmt/include/mp-units/bits/fmt.h index d1be672d..559c720c 100644 --- a/src/core-fmt/include/mp-units/bits/fmt.h +++ b/src/core-fmt/include/mp-units/bits/fmt.h @@ -442,7 +442,7 @@ public: template class dynamic_specs_handler : public specs_setter { public: - using char_type = TYPENAME ParseContext::char_type; + using char_type = MP_UNITS_TYPENAME ParseContext::char_type; constexpr dynamic_specs_handler(dynamic_format_specs& specs, ParseContext& ctx) : specs_setter(specs), specs_(specs), context_(ctx) diff --git a/src/core-fmt/include/mp-units/format.h b/src/core-fmt/include/mp-units/format.h index ff54afbf..60ae49c3 100644 --- a/src/core-fmt/include/mp-units/format.h +++ b/src/core-fmt/include/mp-units/format.h @@ -265,7 +265,7 @@ template struct MP_UNITS_STD_FMT::formatter, CharT> { private: using quantity = mp_units::quantity; - using iterator = TYPENAME MP_UNITS_STD_FMT::basic_format_parse_context::iterator; + using iterator = MP_UNITS_TYPENAME MP_UNITS_STD_FMT::basic_format_parse_context::iterator; bool quantity_value = false; bool quantity_unit = false; diff --git a/src/core/include/mp-units/bits/expression_template.h b/src/core/include/mp-units/bits/expression_template.h index 7e83c6a3..03727e4e 100644 --- a/src/core/include/mp-units/bits/expression_template.h +++ b/src/core/include/mp-units/bits/expression_template.h @@ -113,7 +113,7 @@ struct expr_type_impl> : std::type_identity {}; } // namespace detail template -using expr_type = TYPENAME detail::expr_type_impl::type; +using expr_type = MP_UNITS_TYPENAME detail::expr_type_impl::type; namespace detail { @@ -173,24 +173,25 @@ struct expr_consolidate_impl> { template requires(!is_specialization_of_power) struct expr_consolidate_impl> { - using type = TYPENAME expr_consolidate_impl, Rest...>>::type; + using type = MP_UNITS_TYPENAME expr_consolidate_impl, Rest...>>::type; }; // replaces the instance of a type and a power of it with one with incremented power template struct expr_consolidate_impl, Rest...>> { - using type = TYPENAME expr_consolidate_impl::exponent + 1>, Rest...>>::type; + using type = + MP_UNITS_TYPENAME expr_consolidate_impl::exponent + 1>, Rest...>>::type; }; // accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`) template struct expr_consolidate_impl, power, Rest...>> { static constexpr ratio r = power::exponent + power::exponent; - using type = TYPENAME expr_consolidate_impl, Rest...>>::type; + using type = MP_UNITS_TYPENAME expr_consolidate_impl, Rest...>>::type; }; template -using expr_consolidate = TYPENAME expr_consolidate_impl::type; +using expr_consolidate = MP_UNITS_TYPENAME expr_consolidate_impl::type; /** diff --git a/src/core/include/mp-units/bits/external/hacks.h b/src/core/include/mp-units/bits/external/hacks.h index 5ae762f3..009b2059 100644 --- a/src/core/include/mp-units/bits/external/hacks.h +++ b/src/core/include/mp-units/bits/external/hacks.h @@ -99,21 +99,21 @@ #if MP_UNITS_COMP_MSVC || (MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 16) -#define TYPENAME typename +#define MP_UNITS_TYPENAME typename #else -#define TYPENAME +#define MP_UNITS_TYPENAME #endif #if MP_UNITS_COMP_CLANG -#define CONSTEVAL constexpr +#define MP_UNITS_CONSTEVAL constexpr #else -#define CONSTEVAL consteval +#define MP_UNITS_CONSTEVAL consteval #endif diff --git a/src/core/include/mp-units/bits/external/type_list.h b/src/core/include/mp-units/bits/external/type_list.h index 75265853..5369ce18 100644 --- a/src/core/include/mp-units/bits/external/type_list.h +++ b/src/core/include/mp-units/bits/external/type_list.h @@ -75,7 +75,7 @@ struct type_list_map_impl, To> { } // namespace detail template typename To> -using type_list_map = TYPENAME detail::type_list_map_impl::type; +using type_list_map = MP_UNITS_TYPENAME detail::type_list_map_impl::type; // element @@ -123,7 +123,7 @@ struct type_list_front_impl> { } // namespace detail template -using type_list_front = TYPENAME detail::type_list_front_impl::type; +using type_list_front = MP_UNITS_TYPENAME detail::type_list_front_impl::type; // back @@ -147,7 +147,7 @@ struct type_list_push_front_impl, NewTypes...> { } // namespace detail template -using type_list_push_front = TYPENAME detail::type_list_push_front_impl::type; +using type_list_push_front = MP_UNITS_TYPENAME detail::type_list_push_front_impl::type; // push_back @@ -165,7 +165,7 @@ struct type_list_push_back_impl, NewTypes...> { } // namespace detail template -using type_list_push_back = TYPENAME detail::type_list_push_back_impl::type; +using type_list_push_back = MP_UNITS_TYPENAME detail::type_list_push_back_impl::type; // join @@ -179,13 +179,13 @@ struct type_list_join_impl { template typename List, typename... First, typename... Second, typename... Rest> struct type_list_join_impl, List, Rest...> { - using type = TYPENAME type_list_join_impl, Rest...>::type; + using type = MP_UNITS_TYPENAME type_list_join_impl, Rest...>::type; }; } // namespace detail template -using type_list_join = TYPENAME detail::type_list_join_impl::type; +using type_list_join = MP_UNITS_TYPENAME detail::type_list_join_impl::type; // split @@ -246,21 +246,22 @@ template typename List, typename Lhs1, typename... LhsRest template typename Pred> requires Pred::value struct type_list_merge_sorted_impl, List, Pred> { - using type = TYPENAME type_list_push_front_impl< + using type = MP_UNITS_TYPENAME type_list_push_front_impl< typename type_list_merge_sorted_impl, List, Pred>::type, Lhs1>::type; }; template typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest, template typename Pred> struct type_list_merge_sorted_impl, List, Pred> { - using type = TYPENAME type_list_push_front_impl< + using type = MP_UNITS_TYPENAME type_list_push_front_impl< typename type_list_merge_sorted_impl, List, Pred>::type, Rhs1>::type; }; } // namespace detail template typename Pred> -using type_list_merge_sorted = TYPENAME detail::type_list_merge_sorted_impl::type; +using type_list_merge_sorted = + MP_UNITS_TYPENAME detail::type_list_merge_sorted_impl::type; // sort @@ -284,15 +285,15 @@ template typename List, typename... Types, template, Pred> { using types = List; using split = type_list_split_half>; - using sorted_left = TYPENAME type_list_sort_impl::type; - using sorted_right = TYPENAME type_list_sort_impl::type; - using type = TYPENAME type_list_merge_sorted_impl::type; + using sorted_left = MP_UNITS_TYPENAME type_list_sort_impl::type; + using sorted_right = MP_UNITS_TYPENAME type_list_sort_impl::type; + using type = MP_UNITS_TYPENAME type_list_merge_sorted_impl::type; }; } // namespace detail template typename Pred> -using type_list_sort = TYPENAME detail::type_list_sort_impl::type; +using type_list_sort = MP_UNITS_TYPENAME detail::type_list_sort_impl::type; } // namespace mp_units diff --git a/src/core/include/mp-units/bits/external/type_traits.h b/src/core/include/mp-units/bits/external/type_traits.h index 6c4f2d9a..65223343 100644 --- a/src/core/include/mp-units/bits/external/type_traits.h +++ b/src/core/include/mp-units/bits/external/type_traits.h @@ -46,7 +46,7 @@ struct conditional_impl { } // namespace detail template -using conditional = TYPENAME detail::conditional_impl::template type; +using conditional = MP_UNITS_TYPENAME detail::conditional_impl::template type; // is_same template diff --git a/src/core/include/mp-units/bits/magnitude.h b/src/core/include/mp-units/bits/magnitude.h index f492fc50..6c1dc9ec 100644 --- a/src/core/include/mp-units/bits/magnitude.h +++ b/src/core/include/mp-units/bits/magnitude.h @@ -194,7 +194,7 @@ template } template -[[nodiscard]] CONSTEVAL ratio get_exponent(Element) +[[nodiscard]] MP_UNITS_CONSTEVAL ratio get_exponent(Element) { if constexpr (detail::is_specialization_of_power_v) return Element::exponent; diff --git a/src/core/include/mp-units/bits/ratio.h b/src/core/include/mp-units/bits/ratio.h index 529d4d17..a3928663 100644 --- a/src/core/include/mp-units/bits/ratio.h +++ b/src/core/include/mp-units/bits/ratio.h @@ -33,7 +33,7 @@ namespace mp_units { namespace detail { template -[[nodiscard]] CONSTEVAL T abs(T v) noexcept +[[nodiscard]] MP_UNITS_CONSTEVAL T abs(T v) noexcept { return v < 0 ? -v : v; } @@ -67,7 +67,7 @@ struct ratio { std::intmax_t num; std::intmax_t den; - CONSTEVAL explicit(false) ratio(std::intmax_t n, std::intmax_t d = 1) : num{n}, den{d} + MP_UNITS_CONSTEVAL explicit(false) ratio(std::intmax_t n, std::intmax_t d = 1) : num{n}, den{d} { gsl_Expects(den != 0); if (num == 0) @@ -82,14 +82,14 @@ struct ratio { [[nodiscard]] friend consteval bool operator==(ratio, ratio) = default; [[nodiscard]] friend consteval auto operator<=>(ratio lhs, ratio rhs) { return (lhs - rhs).num <=> 0; } - [[nodiscard]] friend CONSTEVAL ratio operator-(ratio r) { return ratio{-r.num, r.den}; } + [[nodiscard]] friend MP_UNITS_CONSTEVAL ratio operator-(ratio r) { return ratio{-r.num, r.den}; } - [[nodiscard]] friend CONSTEVAL ratio operator+(ratio lhs, ratio rhs) + [[nodiscard]] friend MP_UNITS_CONSTEVAL ratio operator+(ratio lhs, ratio rhs) { return ratio{lhs.num * rhs.den + lhs.den * rhs.num, lhs.den * rhs.den}; } - [[nodiscard]] friend CONSTEVAL ratio operator-(ratio lhs, ratio rhs) { return lhs + (-rhs); } + [[nodiscard]] friend MP_UNITS_CONSTEVAL ratio operator-(ratio lhs, ratio rhs) { return lhs + (-rhs); } [[nodiscard]] friend consteval ratio operator*(ratio lhs, ratio rhs) { diff --git a/src/core/include/mp-units/bits/sudo_cast.h b/src/core/include/mp-units/bits/sudo_cast.h index 8da1f0c5..1917c1aa 100644 --- a/src/core/include/mp-units/bits/sudo_cast.h +++ b/src/core/include/mp-units/bits/sudo_cast.h @@ -62,11 +62,11 @@ template constexpr auto q_unit = std::remove_reference_t::unit; if constexpr (q_unit == To::unit) { // no scaling of the number needed - return make_quantity( - static_cast(std::forward(q).number())); // this is the only (and recommended) way to do - // a truncating conversion on a number, so we are - // using static_cast to suppress all the compiler - // warnings on conversions + return make_quantity(static_cast( + std::forward(q).number())); // this is the only (and recommended) way to do + // a truncating conversion on a number, so we are + // using static_cast to suppress all the compiler + // warnings on conversions } else { // scale the number constexpr Magnitude auto c_mag = get_canonical_unit(q_unit).mag / get_canonical_unit(To::unit).mag; @@ -78,8 +78,8 @@ template using multiplier_type = conditional, std::common_type_t, c_mag_type>; constexpr auto val = [](Magnitude auto m) { return get_value(m); }; - return static_cast(static_cast(std::forward(q).number()) * val(num) / val(den) * - val(irr)) * + return static_cast(static_cast(std::forward(q).number()) * val(num) / + val(den) * val(irr)) * To::reference; } } diff --git a/src/utility/include/mp-units/chrono.h b/src/utility/include/mp-units/chrono.h index 62918fae..1c938f19 100644 --- a/src/utility/include/mp-units/chrono.h +++ b/src/utility/include/mp-units/chrono.h @@ -96,8 +96,8 @@ template QP> requires is_specialization_of, chrono_point_origin_> [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp) { - using clock = TYPENAME decltype(QP::absolute_point_origin)::clock; - using rep = TYPENAME QP::rep; + using clock = MP_UNITS_TYPENAME decltype(QP::absolute_point_origin)::clock; + using rep = MP_UNITS_TYPENAME QP::rep; constexpr auto canonical = detail::get_canonical_unit(QP::unit); constexpr ratio r = as_ratio(canonical.mag); using ret_type = std::chrono::time_point>>; diff --git a/src/utility/include/mp-units/random.h b/src/utility/include/mp-units/random.h index efe579f5..570f1742 100644 --- a/src/utility/include/mp-units/random.h +++ b/src/utility/include/mp-units/random.h @@ -54,7 +54,7 @@ static std::vector bl_qty_to_rep(std::initializer_list& bl) template inline static std::vector fw_bl_pwc(std::initializer_list& bl, UnaryOperation fw) { - using rep = TYPENAME Q::rep; + using rep = MP_UNITS_TYPENAME Q::rep; std::vector w_bl; w_bl.reserve(bl.size()); for (const Q& qty : bl) { @@ -84,8 +84,8 @@ static std::vector fw_bl_pwl(std::initializer_list& bl, Unar template requires std::integral struct uniform_int_distribution : public std::uniform_int_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::uniform_int_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::uniform_int_distribution; uniform_int_distribution() : base() {} uniform_int_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {} @@ -106,8 +106,8 @@ struct uniform_int_distribution : public std::uniform_int_distribution requires std::floating_point struct uniform_real_distribution : public std::uniform_real_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::uniform_real_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::uniform_real_distribution; uniform_real_distribution() : base() {} uniform_real_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {} @@ -128,8 +128,8 @@ struct uniform_real_distribution : public std::uniform_real_distribution requires std::integral struct binomial_distribution : public std::binomial_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::binomial_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::binomial_distribution; binomial_distribution() : base() {} binomial_distribution(const Q& t, double p) : base(t.number(), p) {} @@ -149,8 +149,8 @@ struct binomial_distribution : public std::binomial_distribution requires std::integral struct negative_binomial_distribution : public std::negative_binomial_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::negative_binomial_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::negative_binomial_distribution; negative_binomial_distribution() : base() {} negative_binomial_distribution(const Q& k, double p) : base(k.number(), p) {} @@ -170,8 +170,8 @@ struct negative_binomial_distribution : public std::negative_binomial_distributi template requires std::integral struct geometric_distribution : public std::geometric_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::geometric_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::geometric_distribution; geometric_distribution() : base() {} geometric_distribution(double p) : base(p) {} @@ -189,8 +189,8 @@ struct geometric_distribution : public std::geometric_distribution requires std::integral struct poisson_distribution : public std::poisson_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::poisson_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::poisson_distribution; poisson_distribution() : base() {} explicit poisson_distribution(double p) : base(p) {} @@ -208,8 +208,8 @@ struct poisson_distribution : public std::poisson_distribution template requires std::floating_point struct exponential_distribution : public std::exponential_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::exponential_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::exponential_distribution; exponential_distribution() : base() {} explicit exponential_distribution(const rep& lambda) : base(lambda) {} @@ -227,8 +227,8 @@ struct exponential_distribution : public std::exponential_distribution requires std::floating_point struct gamma_distribution : public std::gamma_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::gamma_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::gamma_distribution; gamma_distribution() : base() {} gamma_distribution(const rep& alpha, const rep& beta) : base(alpha, beta) {} @@ -246,8 +246,8 @@ struct gamma_distribution : public std::gamma_distribution { template requires std::floating_point struct weibull_distribution : public std::weibull_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::weibull_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::weibull_distribution; weibull_distribution() : base() {} weibull_distribution(const rep& a, const rep& b) : base(a, b) {} @@ -265,8 +265,8 @@ struct weibull_distribution : public std::weibull_distribution template requires std::floating_point struct extreme_value_distribution : public std::extreme_value_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::extreme_value_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::extreme_value_distribution; extreme_value_distribution() : base() {} extreme_value_distribution(const Q& a, const rep& b) : base(a.number(), b) {} @@ -286,8 +286,8 @@ struct extreme_value_distribution : public std::extreme_value_distribution requires std::floating_point struct normal_distribution : public std::normal_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::normal_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::normal_distribution; normal_distribution() : base() {} normal_distribution(const Q& mean, const Q& stddev) : base(mean.number(), stddev.number()) {} @@ -308,8 +308,8 @@ struct normal_distribution : public std::normal_distribution { template requires std::floating_point struct lognormal_distribution : public std::lognormal_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::lognormal_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::lognormal_distribution; lognormal_distribution() : base() {} lognormal_distribution(const Q& m, const Q& s) : base(m.number(), s.number()) {} @@ -330,8 +330,8 @@ struct lognormal_distribution : public std::lognormal_distribution requires std::floating_point struct chi_squared_distribution : public std::chi_squared_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::chi_squared_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::chi_squared_distribution; chi_squared_distribution() : base() {} explicit chi_squared_distribution(const rep& n) : base(n) {} @@ -349,8 +349,8 @@ struct chi_squared_distribution : public std::chi_squared_distribution requires std::floating_point struct cauchy_distribution : public std::cauchy_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::cauchy_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::cauchy_distribution; cauchy_distribution() : base() {} cauchy_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {} @@ -371,8 +371,8 @@ struct cauchy_distribution : public std::cauchy_distribution { template requires std::floating_point struct fisher_f_distribution : public std::fisher_f_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::fisher_f_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::fisher_f_distribution; fisher_f_distribution() : base() {} fisher_f_distribution(const rep& m, const rep& n) : base(m, n) {} @@ -390,8 +390,8 @@ struct fisher_f_distribution : public std::fisher_f_distribution requires std::floating_point struct student_t_distribution : public std::student_t_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::student_t_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::student_t_distribution; student_t_distribution() : base() {} explicit student_t_distribution(const rep& n) : base(n) {} @@ -409,8 +409,8 @@ struct student_t_distribution : public std::student_t_distribution requires std::integral struct discrete_distribution : public std::discrete_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::discrete_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::discrete_distribution; discrete_distribution() : base() {} @@ -440,8 +440,8 @@ struct discrete_distribution : public std::discrete_distribution requires std::floating_point class piecewise_constant_distribution : public std::piecewise_constant_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::piecewise_constant_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::piecewise_constant_distribution; template piecewise_constant_distribution(const std::vector& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w) @@ -498,8 +498,8 @@ public: template requires std::floating_point class piecewise_linear_distribution : public std::piecewise_linear_distribution { - using rep = TYPENAME Q::rep; - using base = TYPENAME std::piecewise_linear_distribution; + using rep = MP_UNITS_TYPENAME Q::rep; + using base = MP_UNITS_TYPENAME std::piecewise_linear_distribution; template piecewise_linear_distribution(const std::vector& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)