mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-03 12:24:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

build: got rid of old gcc hacks

Browse Source
This commit is contained in:
Mateusz Pusz
2023-09-26 18:25:03 +02:00
parent 25fee701a0
commit 94bd2a23ca
3 changed files with 1 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/core/include/mp-units/bits/external/hacks.h vendored
View File

@@ -96,31 +96,11 @@
#if MP_UNITS_COMP_MSVC #if MP_UNITS_COMP_MSVC
#define MP_UNITS_CONSTRAINED_AUTO_WORKAROUND(X) #define MP_UNITS_CONSTRAINED_AUTO_WORKAROUND(X)
#else
#define MP_UNITS_CONSTRAINED_AUTO_WORKAROUND(X) X
#endif
#if MP_UNITS_COMP_MSVC || (MP_UNITS_COMP_GCC && MP_UNITS_COMP_GCC < 11)
#define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) #define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X)
#else #else
#define MP_UNITS_CONSTRAINED_AUTO_WORKAROUND(X) X
#define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) X #define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) X
#endif #endif
namespace std {
#if MP_UNITS_COMP_GCC
template<class T>
concept default_constructible = constructible_from<T>;
#endif
} // namespace std

2
test/unit_test/static/quantity_point_test.cpp
View File

@@ -587,14 +587,12 @@ static_assert((tower_peak + 2. * km).in(km).quantity_from_origin_.numerical_valu
static_assert((tower_peak + 2. * km).in(m).quantity_from_origin_.numerical_value_ == 2000.); static_assert((tower_peak + 2. * km).in(m).quantity_from_origin_.numerical_value_ == 2000.);
static_assert((tower_peak + 2000. * m).in(km).quantity_from_origin_.numerical_value_ == 2.); static_assert((tower_peak + 2000. * m).in(km).quantity_from_origin_.numerical_value_ == 2.);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, auto, typename> typename QP> template<template<auto, auto, typename> typename QP>
concept invalid_unit_conversion = requires { concept invalid_unit_conversion = requires {
requires !requires { QP<isq::height[m], mean_sea_level, int>(2000 * m).in(km); }; // truncating conversion requires !requires { QP<isq::height[m], mean_sea_level, int>(2000 * m).in(km); }; // truncating conversion
requires !requires { QP<isq::height[m], mean_sea_level, int>(2 * m).in(s); }; // invalid unit requires !requires { QP<isq::height[m], mean_sea_level, int>(2 * m).in(s); }; // invalid unit
}; };
static_assert(invalid_unit_conversion<quantity_point>); static_assert(invalid_unit_conversion<quantity_point>);
#endif
///////// /////////

6
test/unit_test/static/quantity_test.cpp
View File

@@ -45,7 +45,6 @@ static_assert(sizeof(quantity<isq::length[m]>) == sizeof(double));
static_assert(sizeof(quantity<si::metre, short>) == sizeof(short)); static_assert(sizeof(quantity<si::metre, short>) == sizeof(short));
static_assert(sizeof(quantity<isq::length[m], short>) == sizeof(short)); static_assert(sizeof(quantity<isq::length[m], short>) == sizeof(short));
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, typename> typename Q> template<template<auto, typename> typename Q>
concept invalid_types = requires { concept invalid_types = requires {
requires !requires { typename Q<isq::dim_length, double>; }; // dimension instead of reference requires !requires { typename Q<isq::dim_length, double>; }; // dimension instead of reference
@@ -55,7 +54,6 @@ concept invalid_types = requires {
requires !requires { typename Q<isq::position_vector[si::metre], double>; }; // vector representation expected requires !requires { typename Q<isq::position_vector[si::metre], double>; }; // vector representation expected
}; };
static_assert(invalid_types<quantity>); static_assert(invalid_types<quantity>);
#endif
static_assert(std::is_trivially_default_constructible_v<quantity<isq::length[m]>>); static_assert(std::is_trivially_default_constructible_v<quantity<isq::length[m]>>);
static_assert(std::is_trivially_copy_constructible_v<quantity<isq::length[m]>>); static_assert(std::is_trivially_copy_constructible_v<quantity<isq::length[m]>>);
@@ -208,14 +206,12 @@ static_assert(quantity<isq::length[m]>(2000. * m).in(km).numerical_value_ == 2.)
static_assert(quantity<isq::length[km], int>(2 * km).in(km).numerical_value_ == 2); static_assert(quantity<isq::length[km], int>(2 * km).in(km).numerical_value_ == 2);
static_assert(quantity<isq::length[km], int>(2 * km).in(m).numerical_value_ == 2000); static_assert(quantity<isq::length[km], int>(2 * km).in(m).numerical_value_ == 2000);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, typename> typename Q> template<template<auto, typename> typename Q>
concept invalid_unit_conversion = requires { concept invalid_unit_conversion = requires {
requires !requires { Q<isq::length[m], int>(2000 * m).in(km); }; // truncating conversion requires !requires { Q<isq::length[m], int>(2000 * m).in(km); }; // truncating conversion
requires !requires { Q<isq::length[m], int>(2 * m).in(s); }; // invalid unit requires !requires { Q<isq::length[m], int>(2 * m).in(s); }; // invalid unit
}; };
static_assert(invalid_unit_conversion<quantity>); static_assert(invalid_unit_conversion<quantity>);
#endif
static_assert(quantity<isq::length[km]>(2. * km).numerical_value_in(km) == 2.); static_assert(quantity<isq::length[km]>(2. * km).numerical_value_in(km) == 2.);
static_assert(quantity<isq::length[km]>(2. * km).numerical_value_in(m) == 2000.); static_assert(quantity<isq::length[km]>(2. * km).numerical_value_in(m) == 2000.);
@@ -223,14 +219,12 @@ static_assert(quantity<isq::length[m]>(2000. * m).numerical_value_in(km) == 2.);
static_assert(quantity<isq::length[km], int>(2 * km).numerical_value_in(km) == 2); static_assert(quantity<isq::length[km], int>(2 * km).numerical_value_in(km) == 2);
static_assert(quantity<isq::length[km], int>(2 * km).numerical_value_in(m) == 2000); static_assert(quantity<isq::length[km], int>(2 * km).numerical_value_in(m) == 2000);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, typename> typename Q> template<template<auto, typename> typename Q>
concept invalid_getter_with_unit_conversion = requires { concept invalid_getter_with_unit_conversion = requires {
requires !requires { Q<isq::length[m], int>(2000 * m).numerical_value_in(km); }; // truncating conversion requires !requires { Q<isq::length[m], int>(2000 * m).numerical_value_in(km); }; // truncating conversion
requires !requires { Q<isq::length[m], int>(2 * m).numerical_value_in(s); }; // invalid unit requires !requires { Q<isq::length[m], int>(2 * m).numerical_value_in(s); }; // invalid unit
}; };
static_assert(invalid_getter_with_unit_conversion<quantity>); static_assert(invalid_getter_with_unit_conversion<quantity>);
#endif
/////////////////////////////////////// ///////////////////////////////////////