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

refactor!: replace one_rep with reference<D, U>

Browse Source
This commit is contained in:
Johel Ernesto Guerrero Peña authored and Mateusz Pusz committed 2021-03-18 22:37:25 +01:00
1 parent bf27b256b2
commit 9a520edfe9
65 files changed
+798 -721
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

test/unit_test/static/quantity_kind_test.cpp
+15 -2
View File
@@ -434,6 +434,11 @@ concept invalid_compound_assignments = requires(quantity_kind<Width, metre, int>
requires !requires { w *= 1 * km / m; };
requires !requires { w /= 1 * km / m; };
requires !requires { w %= 1 * km / m; };
requires !requires { w += m; };
requires !requires { w -= m; };
requires !requires { w *= m; };
requires !requires { w /= m; };
requires !requires { w %= m; };
requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
@@ -478,10 +483,12 @@ static_assert(!std::is_invocable_v<std::plus<>, width<metre>, double>);
static_assert(!std::is_invocable_v<std::plus<>, width<metre>, length<metre>>);
static_assert(!std::is_invocable_v<std::plus<>, width<metre>, quantity_point<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::plus<>, width<metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::plus<>, width<metre>, reference<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::minus<>, width<metre>, double>);
static_assert(!std::is_invocable_v<std::minus<>, width<metre>, length<metre>>);
static_assert(!std::is_invocable_v<std::minus<>, width<metre>, quantity_point<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::minus<>, width<metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::minus<>, width<metre>, reference<dim_length, metre>>);
// clang-format off
static_assert(!std::is_invocable_v<std::plus<>, quantity_kind<downcast_kind<width_kind, dim_one>, one>, quantity_kind<downcast_kind<height_kind, dim_one>, one>>);
@@ -541,6 +548,7 @@ static_assert(same(apples<one, int>(2) * quantity(2), apples<one, int>(4)));
static_assert(same(quantity(2) * apples<one, int>(2), apples<one, int>(4)));
// clang-format off
static_assert(same(width<metre, int>(4 * m) * m, horizontal_area<square_metre, int>(4 * m * m)));
static_assert(same(width<metre, int>(2 * m) * width<metre, int>(2 * m), horizontal_area<square_metre, int>(4 * m * m)));
static_assert(same(width<metre, int>(2 * m) * width<metre, double>(2 * m), horizontal_area<square_metre, double>(4 * m * m)));
static_assert(same(width<metre, double>(2 * m) * width<metre, int>(2 * m), horizontal_area<square_metre, double>(4 * m * m)));
@@ -549,6 +557,7 @@ static_assert(same(width<metre, double>(2 * m) * width<metre, int>(2 * m), horiz
static_assert(same(apples<one, int>(2) * apples<one, int>(2), apples<one, int>(4)));
static_assert(same(apples<one, int>(2) * (2 / apples<one, int>(1)), apples<one, int>(4)));
static_assert(same(width<kilometre>(4 * m) * mm, horizontal_area<square_metre>(4 * m * mm)));
static_assert(same(width<kilometre>(2 * m) * width<millimetre>(2 * m), horizontal_area<square_metre>(4 * m * m)));
static_assert(same(width<metre>(2 * m) * (1 / width<metre>(2 * m)),
quantity_kind<downcast_kind<width_kind, dim_one>, one>(1)));
@@ -626,6 +635,7 @@ static_assert(same(apples<one, int>(8) / apples<one, int>(2), apples<one, int>(4
static_assert(same(apples<one, int>(8) / (2 / apples<one, int>(1)), apples<one, int>(4)));
static_assert(same(horizontal_area<square_metre>(8 * m * m) / width<metre>(2 * m), width<metre>(4 * m)));
static_assert(same(horizontal_area<square_metre>(4 * m * m) / m, width<metre>(4 * m)));
static_assert(same(width<metre, int>(2 * m) % 3, width<metre, int>(2 * m)));
static_assert(same(width<metre, int>(3 * m) % width<metre, int>(2 * m), width<metre, int>(1 * m)));
@@ -634,14 +644,17 @@ static_assert(is_same_v<
decltype((width<metre, std::uint8_t>(0 * m) % width<metre, std::uint8_t>(0 * m)).common().count()),
decltype(std::uint8_t(0) % std::uint8_t(0))>);
static_assert(!std::is_invocable_v<std::multiplies<>, reference<dim_length, metre>, width<metre>>);
static_assert(!std::is_invocable_v<std::multiplies<>, width<metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::multiplies<>, height<metre>, quantity_point<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::multiplies<>, quantity_point<dim_length, metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::divides<>, reference<dim_length, metre>, width<metre>>);
static_assert(!std::is_invocable_v<std::divides<>, width<metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::divides<>, height<metre>, quantity_point<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::divides<>, quantity_point<dim_length, metre>, height<metre>>);
static_assert(!std::is_invocable_v<std::modulus<>, width<metre, int>, reference<dim_length, metre>>);
static_assert(!std::is_invocable_v<std::modulus<>, width<metre, int>, length<metre, int>>);
static_assert(!std::is_invocable_v<std::modulus<>, width<metre, int>, quantity_point<dim_length, metre, int>>);
static_assert(!std::is_invocable_v<std::modulus<>, width<metre, int>, double>);
@@ -690,6 +703,8 @@ concept invalid_equality = requires(quantity_kind<Width, metre, int> w) {
requires !requires { w == 1 * m; };
requires !requires { w != 1.0 * cgs_cm; };
requires !requires { w == 1 * km; };
requires !requires { w != m; };
requires !requires { w == km; };
requires !requires { w != quantity(1); };
requires !requires { w == dimensionless<percent>(1.0); };
requires !requires { w != height<metre, int>(1 * m); };
@@ -770,7 +785,6 @@ static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<cgs::centim
// clang-format on
template<typename Width>
concept invalid_cast = requires {
requires !requires { quantity_kind_cast<width<metre, one_rep>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m)); };
@@ -783,7 +797,6 @@ concept invalid_cast = requires {
requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<one_rep>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<quantity_point<dim_length, metre, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<quantity_point<dim_one, one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
};
test/unit_test/static/quantity_point_kind_test.cpp
-5
View File
@@ -220,9 +220,6 @@ static_assert(construct_from_only<nth_apple<one, double>>(1).relative().common()
static_assert(construct_from_only<nth_apple<one, double>>(short{1}).relative().common() == 1);
static_assert(construct_from_only<nth_apple<one, short>>(1).relative().common() == 1);
static_assert(construct_from_only<nth_apple<one, int>>(1).relative().common() == 1);
static_assert(construct_from_only<nth_apple<one, double>>(one_rep{}).relative().common() == 1);
static_assert(construct_from_only<nth_apple<one, int>>(one_rep{}).relative().common() == 1);
static_assert(construct_from_only<nth_apple<one, short>>(one_rep{}).relative().common() == 1);
static_assert(construct_from_only<nth_apple<percent, int>>(1ULL).relative().common().count() == 1);
static_assert(construct_from_only<nth_apple<percent, double>>(1).relative().common().count() == 1);
static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(1.0));
@@ -605,7 +602,6 @@ static_assert(same(quantity_point_kind_cast<length<centimetre, int>>(abscissa<cg
// clang-format on
template<typename Int>
concept invalid_cast = requires(Int i) {
requires !requires { quantity_point_kind_cast<abscissa<metre, one_rep>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
@@ -620,7 +616,6 @@ concept invalid_cast = requires(Int i) {
requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<one_rep>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<quantity_point<dim_length, metre, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<quantity_point<dim_one, one, Int>>(abscissa<metre, Int>(i * m)); };
};
test/unit_test/static/quantity_test.cpp
+23
View File
@@ -342,6 +342,13 @@ concept invalid_compound_assignments = requires() {
requires !requires(length<Metre, double> l) { l %= 2._q_m; };
requires !requires(length<Metre, double> l) { l %= 2_q_m; };
requires !requires(length<Metre, int> l) { l %= 2._q_m; };
// no unit constants
requires !requires(length<Metre, int> l) { l += m; };
requires !requires(length<Metre, int> l) { l -= m; };
requires !requires(length<Metre, int> l) { l *= m; };
requires !requires(length<Metre, int> l) { l /= m; };
requires !requires(length<Metre, int> l) { l %= m; };
};
static_assert(invalid_compound_assignments<metre, kilometre>);
@@ -363,6 +370,14 @@ concept invalid_binary_operations = requires {
requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
// unit constants
requires !requires { length<Metre, int>(1) + m; };
requires !requires { length<Metre, int>(1) - m; };
requires !requires { length<Metre, int>(1) % m; };
requires !requires { m + length<Metre, int>(1); };
requires !requires { m - length<Metre, int>(1); };
requires !requires { m % length<Metre, int>(1); };
};
static_assert(invalid_binary_operations<metre>);
@@ -542,6 +557,11 @@ static_assert(quantity_cast<one>(10_q_km / 5_q_m).count() == 2000);
static_assert((10_q_s * 2_q_kHz).count() == 20);
// unit constants
static_assert(2_q_m * m == (2_q_m2));
static_assert(2_q_m2 / m == (2_q_m));
// dimensionless
@@ -581,6 +601,9 @@ static_assert((quantity{std::uint8_t(0)} - quantity{std::uint8_t(1)}).count() ==
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} % quantity{std::uint8_t(0)}).count()),
decltype(std::uint8_t(0) % std::uint8_t(0))>);
static_assert(quantity{2} * m == 2_q_m);
static_assert(quantity{2} / m == 2 / 1_q_m);
///////////////////////
// equality operators
test/unit_test/static/unit_constants.cpp
+11 -7
View File
@@ -60,14 +60,15 @@ concept invalid_operations = requires {
};
static_assert(invalid_operations<s>);
constexpr auto m_per_s = m / s;
static_assert(2_q_m / s == 2_q_m_per_s);
static_assert(2 * m / s == 2_q_m_per_s);
static_assert(2 / s * m == 2_q_m_per_s);
static_assert(2 * (m / s) == 2_q_m_per_s);
#if !(UNITS_COMP_GCC == 10 && UNITS_COMP_GCC_MINOR == 1)
constexpr auto m_per_s = m / s;
static_assert(2 * ::m_per_s == 2_q_m_per_s);
static_assert(is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
#endif
static_assert(120 * km / (2 * h) == 60_q_km_per_h);
static_assert(120 * km / 2 / h == 60_q_km_per_h);
@@ -82,14 +83,17 @@ static_assert(is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>)
static_assert(1. / 4 * m2 == 1._q_m2 / 4);
#if !defined(UNITS_COMP_CLANG) // -Wshadow
static_assert([] {
UNITS_DIAGNOSTIC_PUSH
UNITS_DIAGNOSTIC_IGNORE_SHADOW
constexpr bool test_hiding() {
Speed auto v0 = 10 * m / s;
signed s = 2; // hides ^
Length auto v = 20 * m / s;
/* */ v0 = 10 * m / ::s;
return !is_same_v<decltype(v0), decltype(v)>;
}());
#endif
}
static_assert(test_hiding());
UNITS_DIAGNOSTIC_POP
int main() {}