mirror of
https://github.com/mpusz/mp-units.git
synced 2025-08-01 03:14:29 +02:00
Merge branch 'master' into feature/more-value-casts
This commit is contained in:
Yves Delley
@@ -22,5 +22,7 @@
|
||||
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
add_subdirectory(runtime)
|
||||
if(NOT ${projectPrefix}API_FREESTANDING)
|
||||
add_subdirectory(runtime)
|
||||
endif()
|
||||
add_subdirectory(static)
|
||||
|
||||
@@ -24,7 +24,9 @@ cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
find_package(Catch2 3 REQUIRED)
|
||||
|
||||
add_executable(unit_tests_runtime distribution_test.cpp fmt_test.cpp math_test.cpp atomic_test.cpp)
|
||||
add_executable(
|
||||
unit_tests_runtime distribution_test.cpp fixed_string_test.cpp fmt_test.cpp math_test.cpp atomic_test.cpp
|
||||
)
|
||||
if(${projectPrefix}BUILD_CXX_MODULES)
|
||||
target_compile_definitions(unit_tests_runtime PUBLIC ${projectPrefix}MODULES)
|
||||
endif()
|
||||
|
||||
68
test/runtime/fixed_string_test.cpp
Normal file
68
test/runtime/fixed_string_test.cpp
Normal file
@@ -0,0 +1,68 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_exception.hpp>
|
||||
#include <mp-units/compat_macros.h>
|
||||
#include <sstream>
|
||||
#include <string_view>
|
||||
#ifdef MP_UNITS_MODULES
|
||||
import mp_units;
|
||||
#else
|
||||
#include <mp-units/ext/fixed_string.h>
|
||||
#endif
|
||||
|
||||
using namespace mp_units;
|
||||
|
||||
TEST_CASE("fixed_string::at", "[fixed_string]")
|
||||
{
|
||||
basic_fixed_string txt = "abc";
|
||||
SECTION("in range")
|
||||
{
|
||||
CHECK(txt.at(0) == 'a');
|
||||
CHECK(txt.at(1) == 'b');
|
||||
CHECK(txt.at(2) == 'c');
|
||||
}
|
||||
SECTION("out of range")
|
||||
{
|
||||
REQUIRE_THROWS_MATCHES(txt.at(3), std::out_of_range, Catch::Matchers::Message("basic_fixed_string::at"));
|
||||
REQUIRE_THROWS_MATCHES(txt.at(1024), std::out_of_range, Catch::Matchers::Message("basic_fixed_string::at"));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("fixed_string text output", "[fixed_string][ostream][fmt]")
|
||||
{
|
||||
basic_fixed_string txt = "units";
|
||||
SECTION("iostream")
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << txt;
|
||||
CHECK(os.str() == "units");
|
||||
}
|
||||
SECTION("fmt") { CHECK(MP_UNITS_STD_FMT::format("{}", txt) == "units"); }
|
||||
}
|
||||
|
||||
TEST_CASE("fixed_string hash", "[fixed_string][hash]")
|
||||
{
|
||||
basic_fixed_string txt = "units";
|
||||
CHECK(std::hash<fixed_string<5>>{}(txt) == std::hash<std::string_view>{}("units"));
|
||||
}
|
||||
@@ -34,7 +34,6 @@
|
||||
#ifdef MP_UNITS_MODULES
|
||||
import mp_units;
|
||||
#else
|
||||
#include <mp-units/ext/fixed_string.h>
|
||||
#include <mp-units/format.h>
|
||||
#include <mp-units/ostream.h> // IWYU pragma: keep
|
||||
#include <mp-units/systems/cgs.h>
|
||||
@@ -51,18 +50,6 @@ inline constexpr bool mp_units::is_vector<T> = true;
|
||||
using namespace mp_units;
|
||||
using namespace mp_units::si::unit_symbols;
|
||||
|
||||
TEST_CASE("fixed_string", "[text][ostream][fmt]")
|
||||
{
|
||||
basic_fixed_string txt = "units";
|
||||
SECTION("iostream")
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << txt;
|
||||
CHECK(os.str() == "units");
|
||||
}
|
||||
SECTION("fmt") { CHECK(MP_UNITS_STD_FMT::format("{}", txt) == "units"); }
|
||||
}
|
||||
|
||||
TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
|
||||
{
|
||||
std::ostringstream os;
|
||||
|
||||
@@ -32,7 +32,6 @@ add_library(
|
||||
unit_tests_static
|
||||
angular_test.cpp
|
||||
cgs_test.cpp
|
||||
chrono_test.cpp
|
||||
compare_test.cpp
|
||||
concepts_test.cpp
|
||||
# custom_rep_test_min_expl.cpp
|
||||
@@ -40,7 +39,6 @@ add_library(
|
||||
dimension_test.cpp
|
||||
dimension_symbol_test.cpp
|
||||
fixed_string_test.cpp
|
||||
fractional_exponent_quantity.cpp
|
||||
hep_test.cpp
|
||||
iau_test.cpp
|
||||
iec80000_test.cpp
|
||||
@@ -49,7 +47,6 @@ add_library(
|
||||
isq_test.cpp
|
||||
isq_angle_test.cpp
|
||||
# magnitude_test.cpp
|
||||
math_test.cpp
|
||||
natural_test.cpp
|
||||
prime_test.cpp
|
||||
quantity_point_test.cpp
|
||||
@@ -65,5 +62,10 @@ add_library(
|
||||
usc_test.cpp
|
||||
)
|
||||
|
||||
if(NOT ${projectPrefix}API_FREESTANDING)
|
||||
target_sources(unit_tests_static PRIVATE chrono_test.cpp fractional_exponent_quantity.cpp math_test.cpp)
|
||||
endif()
|
||||
|
||||
target_compile_options(unit_tests_static PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Wno-subobject-linkage>)
|
||||
target_link_libraries(unit_tests_static PRIVATE mp-units::mp-units)
|
||||
target_link_libraries(unit_tests_static PRIVATE unit_tests_static_truncating)
|
||||
|
||||
@@ -23,14 +23,18 @@
|
||||
#include <mp-units/systems/isq/space_and_time.h>
|
||||
#include <mp-units/systems/natural.h>
|
||||
#include <mp-units/systems/si.h>
|
||||
#include <optional>
|
||||
#include <type_traits>
|
||||
#if MP_UNITS_HOSTED
|
||||
#include <chrono>
|
||||
#include <complex>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#endif
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
template<typename T>
|
||||
inline constexpr bool mp_units::is_scalar<std::complex<T>> = true;
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
@@ -45,9 +49,9 @@ struct dim_speed : decltype(isq::dim_length / isq::dim_time) {};
|
||||
|
||||
// BaseDimension
|
||||
static_assert(detail::BaseDimension<struct isq::dim_length>);
|
||||
static_assert(!detail::BaseDimension<std::remove_const_t<decltype(isq::dim_length / isq::dim_time)>>);
|
||||
static_assert(!detail::BaseDimension<std::remove_const_t<decltype(inverse(isq::dim_time))>>);
|
||||
static_assert(!detail::BaseDimension<std::remove_const_t<decltype(pow<2>(isq::dim_length))>>);
|
||||
static_assert(!detail::BaseDimension<decltype(isq::dim_length / isq::dim_time)>);
|
||||
static_assert(!detail::BaseDimension<decltype(inverse(isq::dim_time))>);
|
||||
static_assert(!detail::BaseDimension<decltype(pow<2>(isq::dim_length))>);
|
||||
static_assert(!detail::BaseDimension<derived_dimension<struct isq::dim_length, per<struct isq::dim_time>>>);
|
||||
static_assert(!detail::BaseDimension<dim_speed>);
|
||||
static_assert(!detail::BaseDimension<base_dimension<"L">>);
|
||||
@@ -55,9 +59,9 @@ static_assert(!detail::BaseDimension<struct si::metre>);
|
||||
static_assert(!detail::BaseDimension<int>);
|
||||
|
||||
// DerivedDimension
|
||||
static_assert(detail::DerivedDimension<std::remove_const_t<decltype(isq::dim_length / isq::dim_time)>>);
|
||||
static_assert(detail::DerivedDimension<std::remove_const_t<decltype(inverse(isq::dim_time))>>);
|
||||
static_assert(detail::DerivedDimension<std::remove_const_t<decltype(pow<2>(isq::dim_length))>>);
|
||||
static_assert(detail::DerivedDimension<decltype(isq::dim_length / isq::dim_time)>);
|
||||
static_assert(detail::DerivedDimension<decltype(inverse(isq::dim_time))>);
|
||||
static_assert(detail::DerivedDimension<decltype(pow<2>(isq::dim_length))>);
|
||||
static_assert(detail::DerivedDimension<derived_dimension<struct isq::dim_length, per<struct isq::dim_time>>>);
|
||||
static_assert(detail::DerivedDimension<struct dimension_one>);
|
||||
static_assert(!detail::DerivedDimension<dim_speed>);
|
||||
@@ -67,9 +71,9 @@ static_assert(!detail::DerivedDimension<int>);
|
||||
|
||||
// Dimension
|
||||
static_assert(Dimension<struct isq::dim_length>);
|
||||
static_assert(Dimension<std::remove_const_t<decltype(isq::dim_length / isq::dim_time)>>);
|
||||
static_assert(Dimension<std::remove_const_t<decltype(inverse(isq::dim_time))>>);
|
||||
static_assert(Dimension<std::remove_const_t<decltype(pow<2>(isq::dim_length))>>);
|
||||
static_assert(Dimension<decltype(isq::dim_length / isq::dim_time)>);
|
||||
static_assert(Dimension<decltype(inverse(isq::dim_time))>);
|
||||
static_assert(Dimension<decltype(pow<2>(isq::dim_length))>);
|
||||
static_assert(Dimension<derived_dimension<struct isq::dim_length, per<struct isq::dim_time>>>);
|
||||
static_assert(Dimension<struct dimension_one>);
|
||||
static_assert(!Dimension<dim_speed>);
|
||||
@@ -86,9 +90,9 @@ struct speed : decltype(isq::length / isq::time) {}; // this is not recommended
|
||||
static_assert(QuantitySpec<struct isq::length>);
|
||||
static_assert(QuantitySpec<struct isq::radius>);
|
||||
static_assert(QuantitySpec<struct isq::speed>);
|
||||
static_assert(QuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(QuantitySpec<std::remove_const_t<decltype(isq::length / isq::time)>>);
|
||||
static_assert(QuantitySpec<std::remove_const_t<decltype(pow<2>(isq::length))>>);
|
||||
static_assert(QuantitySpec<decltype(kind_of<isq::length>)>);
|
||||
static_assert(QuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(QuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(QuantitySpec<struct dimensionless>);
|
||||
static_assert(!QuantitySpec<speed>);
|
||||
static_assert(!QuantitySpec<struct isq::dim_length>);
|
||||
@@ -99,8 +103,8 @@ static_assert(detail::NamedQuantitySpec<struct isq::length>);
|
||||
static_assert(detail::NamedQuantitySpec<struct isq::radius>);
|
||||
static_assert(detail::NamedQuantitySpec<struct isq::speed>);
|
||||
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(isq::length / isq::time)>>);
|
||||
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(pow<2>(isq::length))>>);
|
||||
static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(detail::NamedQuantitySpec<struct dimensionless>);
|
||||
static_assert(!detail::NamedQuantitySpec<speed>);
|
||||
static_assert(!detail::NamedQuantitySpec<struct isq::dim_length>);
|
||||
@@ -109,10 +113,10 @@ static_assert(!detail::NamedQuantitySpec<int>);
|
||||
// IntermediateDerivedQuantitySpec
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<struct isq::length>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<struct isq::radius>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<decltype(kind_of<isq::length>)>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<struct isq::speed>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<std::remove_const_t<decltype(isq::length / isq::time)>>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<std::remove_const_t<decltype(pow<2>(isq::length))>>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<struct dimensionless>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<speed>);
|
||||
static_assert(!detail::IntermediateDerivedQuantitySpec<struct isq::dim_length>);
|
||||
@@ -123,8 +127,8 @@ static_assert(!detail::QuantityKindSpec<struct isq::length>);
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::radius>);
|
||||
static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::speed>);
|
||||
static_assert(!detail::QuantityKindSpec<std::remove_const_t<decltype(isq::length / isq::time)>>);
|
||||
static_assert(!detail::QuantityKindSpec<std::remove_const_t<decltype(pow<2>(isq::length))>>);
|
||||
static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(!detail::QuantityKindSpec<struct dimensionless>);
|
||||
static_assert(!detail::QuantityKindSpec<speed>);
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::dim_length>);
|
||||
@@ -138,13 +142,13 @@ struct metre_per_second : decltype(si::metre / si::second) {};
|
||||
|
||||
static_assert(Unit<struct si::metre>);
|
||||
static_assert(Unit<struct si::kilogram>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(si::kilo<si::gram>)>>);
|
||||
static_assert(Unit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(Unit<struct natural::electronvolt>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(si::metre / si::second)>>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(inverse(si::second))>>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(mag<10> * si::second)>>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(square(si::metre))>>);
|
||||
static_assert(Unit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
|
||||
static_assert(Unit<decltype(si::metre / si::second)>);
|
||||
static_assert(Unit<decltype(inverse(si::second))>);
|
||||
static_assert(Unit<decltype(mag<10> * si::second)>);
|
||||
static_assert(Unit<decltype(square(si::metre))>);
|
||||
static_assert(Unit<decltype(pow<2>(si::metre))>);
|
||||
static_assert(Unit<struct si::standard_gravity>);
|
||||
static_assert(Unit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(Unit<metre_per_second>);
|
||||
@@ -157,18 +161,20 @@ static_assert(!Unit<named_unit<"?", si::metre, isq::length>>);
|
||||
static_assert(!Unit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!Unit<struct isq::dim_length>);
|
||||
static_assert(!Unit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
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<struct si::kilogram>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(si::kilo<si::gram>)>>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(si::metre / si::second)>>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(inverse(si::second))>>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(square(si::metre))>>);
|
||||
static_assert(!detail::NamedUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
|
||||
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<metre_per_second>);
|
||||
@@ -181,18 +187,20 @@ static_assert(!detail::NamedUnit<named_unit<"?", si::metre, 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>);
|
||||
static_assert(!PrefixableUnit<struct si::kilogram>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(si::kilo<si::gram>)>>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(si::metre / si::second)>>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(inverse(si::second))>>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(square(si::metre))>>);
|
||||
static_assert(!PrefixableUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
|
||||
static_assert(!PrefixableUnit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(!PrefixableUnit<decltype(si::metre / si::second)>);
|
||||
static_assert(!PrefixableUnit<decltype(inverse(si::second))>);
|
||||
static_assert(!PrefixableUnit<decltype(mag<10> * si::second)>);
|
||||
static_assert(!PrefixableUnit<decltype(square(si::metre))>);
|
||||
static_assert(!PrefixableUnit<decltype(pow<2>(si::metre))>);
|
||||
static_assert(PrefixableUnit<struct si::standard_gravity>);
|
||||
static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(!PrefixableUnit<metre_per_second>);
|
||||
@@ -205,18 +213,20 @@ static_assert(!PrefixableUnit<named_unit<"?", si::metre, isq::length>>);
|
||||
static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!PrefixableUnit<struct isq::dim_length>);
|
||||
static_assert(!PrefixableUnit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!PrefixableUnit<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// AssociatedUnit
|
||||
static_assert(AssociatedUnit<struct si::metre>);
|
||||
static_assert(!AssociatedUnit<struct natural::electronvolt>);
|
||||
static_assert(AssociatedUnit<struct si::kilogram>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(si::kilo<si::gram>)>>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(si::metre / si::second)>>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(inverse(si::second))>>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(square(si::metre))>>);
|
||||
static_assert(AssociatedUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
|
||||
static_assert(AssociatedUnit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(AssociatedUnit<decltype(si::metre / si::second)>);
|
||||
static_assert(AssociatedUnit<decltype(inverse(si::second))>);
|
||||
static_assert(AssociatedUnit<decltype(mag<10> * si::second)>);
|
||||
static_assert(AssociatedUnit<decltype(square(si::metre))>);
|
||||
static_assert(AssociatedUnit<decltype(pow<2>(si::metre))>);
|
||||
static_assert(AssociatedUnit<struct si::standard_gravity>);
|
||||
static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(AssociatedUnit<metre_per_second>);
|
||||
@@ -229,7 +239,9 @@ static_assert(!AssociatedUnit<named_unit<"?", si::metre, isq::length>>);
|
||||
static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!AssociatedUnit<struct isq::dim_length>);
|
||||
static_assert(!AssociatedUnit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!AssociatedUnit<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// UnitOf
|
||||
static_assert(UnitOf<struct si::metre, isq::length>);
|
||||
@@ -248,13 +260,13 @@ static_assert(!UnitOf<struct natural::electronvolt, isq::energy>);
|
||||
|
||||
// Reference
|
||||
static_assert(Reference<struct si::metre>);
|
||||
static_assert(Reference<std::remove_const_t<decltype(si::metre / si::second)>>);
|
||||
static_assert(Reference<std::remove_const_t<decltype(isq::length[si::metre])>>);
|
||||
static_assert(Reference<std::remove_const_t<decltype(isq::radius[si::metre])>>);
|
||||
static_assert(Reference<std::remove_const_t<decltype(isq::radius[si::metre] / isq::time[si::second])>>);
|
||||
static_assert(Reference<decltype(si::metre / si::second)>);
|
||||
static_assert(Reference<decltype(isq::length[si::metre])>);
|
||||
static_assert(Reference<decltype(isq::radius[si::metre])>);
|
||||
static_assert(Reference<decltype(isq::radius[si::metre] / isq::time[si::second])>);
|
||||
static_assert(!Reference<struct natural::electronvolt>);
|
||||
static_assert(!Reference<struct isq::length>);
|
||||
static_assert(!Reference<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(!Reference<decltype(kind_of<isq::length>)>);
|
||||
static_assert(!Reference<struct isq::dim_length>);
|
||||
static_assert(!Reference<int>);
|
||||
|
||||
@@ -262,51 +274,57 @@ static_assert(!Reference<int>);
|
||||
static_assert(ReferenceOf<struct si::metre, isq::length>);
|
||||
static_assert(ReferenceOf<struct si::metre, isq::radius>);
|
||||
static_assert(!ReferenceOf<struct si::second, isq::length>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::length[si::metre])>, isq::length>);
|
||||
static_assert(!ReferenceOf<std::remove_const_t<decltype(isq::length[si::metre])>, isq::radius>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::radius[si::metre])>, isq::length>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::radius[si::metre])>, isq::radius>);
|
||||
static_assert(ReferenceOf<decltype(isq::length[si::metre]), isq::length>);
|
||||
static_assert(!ReferenceOf<decltype(isq::length[si::metre]), isq::radius>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::length>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::radius>);
|
||||
static_assert(!ReferenceOf<struct si::second, isq::dim_length>);
|
||||
|
||||
static_assert(ReferenceOf<struct one, dimensionless>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(dimensionless[one])>, dimensionless>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::rotation[one])>, isq::rotation>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::rotation[one])>, dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(dimensionless[one]), dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(isq::rotation[one]), isq::rotation>);
|
||||
static_assert(ReferenceOf<decltype(isq::rotation[one]), dimensionless>);
|
||||
static_assert(ReferenceOf<struct si::radian, isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<struct si::radian, dimensionless>);
|
||||
static_assert(ReferenceOf<std::remove_const_t<decltype(isq::angular_measure[si::radian])>, isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<std::remove_const_t<decltype(isq::angular_measure[si::radian])>, dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<decltype(isq::angular_measure[si::radian]), dimensionless>);
|
||||
static_assert(ReferenceOf<struct one, isq::rotation>);
|
||||
static_assert(ReferenceOf<struct one, isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<std::remove_const_t<decltype(dimensionless[one])>, isq::rotation>);
|
||||
static_assert(!ReferenceOf<std::remove_const_t<decltype(dimensionless[one])>, isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::rotation>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::angular_measure>);
|
||||
|
||||
// Representation
|
||||
static_assert(Representation<int>);
|
||||
static_assert(Representation<double>);
|
||||
static_assert(Representation<std::complex<double>>);
|
||||
static_assert(!Representation<bool>);
|
||||
static_assert(!Representation<std::optional<int>>);
|
||||
static_assert(!Representation<std::chrono::seconds>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(Representation<std::complex<double>>);
|
||||
static_assert(!Representation<std::string>);
|
||||
static_assert(!Representation<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// RepresentationOf
|
||||
static_assert(RepresentationOf<int, quantity_character::scalar>);
|
||||
static_assert(RepresentationOf<double, quantity_character::scalar>);
|
||||
static_assert(RepresentationOf<std::complex<double>, quantity_character::scalar>);
|
||||
static_assert(!RepresentationOf<bool, quantity_character::scalar>);
|
||||
static_assert(!RepresentationOf<std::optional<int>, quantity_character::scalar>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(RepresentationOf<std::complex<double>, quantity_character::scalar>);
|
||||
static_assert(!RepresentationOf<std::chrono::seconds, quantity_character::scalar>);
|
||||
static_assert(!RepresentationOf<std::string, quantity_character::scalar>);
|
||||
#endif
|
||||
|
||||
// Quantity
|
||||
static_assert(Quantity<quantity<si::metre>>);
|
||||
static_assert(Quantity<quantity<isq::length[si::metre]>>);
|
||||
static_assert(Quantity<quantity<si::metre, int>>);
|
||||
static_assert(Quantity<quantity<isq::length[si::metre], int>>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!Quantity<std::chrono::seconds>);
|
||||
#endif
|
||||
static_assert(!Quantity<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!Quantity<std::remove_const_t<decltype(isq::length[si::metre])>>);
|
||||
static_assert(!Quantity<decltype(isq::length[si::metre])>);
|
||||
|
||||
// QuantityOf
|
||||
static_assert(QuantityOf<quantity<si::metre>, isq::length>);
|
||||
@@ -332,8 +350,10 @@ static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::rotation>);
|
||||
static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::angular_measure>);
|
||||
|
||||
// QuantityLike
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(QuantityLike<std::chrono::seconds>);
|
||||
static_assert(QuantityLike<std::chrono::hours>);
|
||||
#endif
|
||||
static_assert(!QuantityLike<quantity<isq::time[si::second]>>);
|
||||
static_assert(!QuantityLike<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(!QuantityLike<int>);
|
||||
@@ -345,12 +365,14 @@ static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_relative_origin, int>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_relative_origin>>);
|
||||
static_assert(!QuantityPoint<std::remove_const_t<decltype(isq::length[si::metre])>>);
|
||||
static_assert(!QuantityPoint<decltype(isq::length[si::metre])>);
|
||||
static_assert(!QuantityPoint<absolute_point_origin<struct my_origin, isq::length>>);
|
||||
static_assert(!QuantityPoint<struct my_origin>);
|
||||
static_assert(!QuantityPoint<struct my_relative_origin>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!QuantityPoint<std::chrono::seconds>);
|
||||
static_assert(!QuantityPoint<std::chrono::time_point<std::chrono::system_clock>>);
|
||||
#endif
|
||||
static_assert(!QuantityPoint<int>);
|
||||
|
||||
// QuantityPointOf
|
||||
@@ -383,9 +405,11 @@ static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>);
|
||||
static_assert(!PointOrigin<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], my_origin>>);
|
||||
static_assert(!PointOrigin<std::remove_const_t<decltype(isq::length[si::metre])>>);
|
||||
static_assert(!PointOrigin<decltype(isq::length[si::metre])>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!PointOrigin<std::chrono::seconds>);
|
||||
static_assert(!PointOrigin<std::chrono::time_point<std::chrono::system_clock>>);
|
||||
#endif
|
||||
static_assert(!PointOrigin<int>);
|
||||
|
||||
// PointOriginFor
|
||||
@@ -407,14 +431,18 @@ static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>,
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::time>);
|
||||
static_assert(!PointOriginFor<std::remove_const_t<decltype(isq::length[si::metre])>, isq::length>);
|
||||
static_assert(!PointOriginFor<decltype(isq::length[si::metre]), isq::length>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!PointOriginFor<std::chrono::seconds, isq::length>);
|
||||
static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, isq::length>);
|
||||
#endif
|
||||
static_assert(!PointOriginFor<int, isq::length>);
|
||||
|
||||
// QuantityPointLike
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>);
|
||||
static_assert(!QuantityPointLike<std::chrono::seconds>);
|
||||
#endif
|
||||
static_assert(!QuantityPointLike<quantity<isq::time[si::second]>>);
|
||||
static_assert(!QuantityPointLike<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!QuantityPointLike<int>);
|
||||
|
||||
@@ -82,7 +82,7 @@ static_assert(!std::convertible_to<min_impl<double>, quantity<si::metre, min_imp
|
||||
|
||||
// multiply syntax should work
|
||||
template<typename T, auto U>
|
||||
concept creates_quantity = Unit<std::remove_cvref_t<decltype(U)>> && requires { T{} * U; };
|
||||
concept creates_quantity = Unit<decltype(U)> && requires { T{} * U; };
|
||||
|
||||
static_assert(creates_quantity<min_impl<int>, si::metre>);
|
||||
static_assert(creates_quantity<min_impl<double>, si::metre>);
|
||||
|
||||
@@ -21,42 +21,161 @@
|
||||
// SOFTWARE.
|
||||
|
||||
#include <mp-units/ext/fixed_string.h>
|
||||
#include <array>
|
||||
#include <string_view>
|
||||
|
||||
using namespace mp_units;
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr std::array array = {'a', 'b', 'c'};
|
||||
|
||||
auto from_string = [] {
|
||||
std::string_view txt = "abc";
|
||||
return fixed_string<3>(std::from_range, txt);
|
||||
};
|
||||
|
||||
auto from_string_iter = [] {
|
||||
std::string_view txt = "abc";
|
||||
return fixed_string<3>(txt.begin(), txt.end());
|
||||
};
|
||||
|
||||
constexpr fixed_string<0> txt0;
|
||||
constexpr basic_fixed_string txt1('a');
|
||||
constexpr basic_fixed_string txt2('a', 'b', 'c');
|
||||
constexpr basic_fixed_string txt3 = "abc";
|
||||
constexpr fixed_string<3> txt4(array.begin(), array.end());
|
||||
constexpr basic_fixed_string txt5(std::from_range, array);
|
||||
constexpr basic_fixed_string txt6(from_string());
|
||||
constexpr basic_fixed_string txt7(from_string_iter());
|
||||
|
||||
constexpr fixed_string<3> txt8(txt2.begin(), txt2.end());
|
||||
constexpr fixed_string<3> txt9(txt2.rbegin(), txt2.rend());
|
||||
|
||||
static_assert(txt0.size() == 0);
|
||||
static_assert(txt1.size() == 1);
|
||||
static_assert(txt2.size() == 3);
|
||||
static_assert(txt3.size() == 3);
|
||||
static_assert(txt4.size() == 3);
|
||||
static_assert(txt5.size() == 3);
|
||||
static_assert(txt6.size() == 3);
|
||||
static_assert(txt7.size() == 3);
|
||||
static_assert(txt8.size() == 3);
|
||||
static_assert(txt9.size() == 3);
|
||||
|
||||
static_assert(txt0.length() == 0);
|
||||
static_assert(txt1.length() == 1);
|
||||
static_assert(txt2.length() == 3);
|
||||
|
||||
static_assert(txt0.max_size() == 0);
|
||||
static_assert(txt1.max_size() == 1);
|
||||
static_assert(txt2.max_size() == 3);
|
||||
|
||||
static_assert(txt0.empty() == true);
|
||||
static_assert(txt1.empty() == false);
|
||||
static_assert(txt2.empty() == false);
|
||||
static_assert(txt3.empty() == false);
|
||||
static_assert(txt4.empty() == false);
|
||||
static_assert(txt5.empty() == false);
|
||||
static_assert(txt6.empty() == false);
|
||||
static_assert(txt7.empty() == false);
|
||||
static_assert(txt8.empty() == false);
|
||||
static_assert(txt9.empty() == false);
|
||||
|
||||
static_assert(txt1[0] == 'a');
|
||||
static_assert(txt2[0] == 'a');
|
||||
static_assert(txt2[1] == 'b');
|
||||
static_assert(txt2[2] == 'c');
|
||||
static_assert(txt9[0] == 'c');
|
||||
static_assert(txt9[1] == 'b');
|
||||
static_assert(txt9[2] == 'a');
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(txt1.at(0) == 'a');
|
||||
static_assert(txt2.at(0) == 'a');
|
||||
static_assert(txt2.at(1) == 'b');
|
||||
static_assert(txt2.at(2) == 'c');
|
||||
static_assert(txt9.at(0) == 'c');
|
||||
static_assert(txt9.at(1) == 'b');
|
||||
static_assert(txt9.at(2) == 'a');
|
||||
#endif
|
||||
|
||||
static_assert(txt1.front() == 'a');
|
||||
static_assert(txt1.back() == 'a');
|
||||
static_assert(txt2.front() == 'a');
|
||||
static_assert(txt2.back() == 'c');
|
||||
static_assert(txt5.front() == 'a');
|
||||
static_assert(txt5.back() == 'c');
|
||||
static_assert(txt6.front() == 'a');
|
||||
static_assert(txt6.back() == 'c');
|
||||
static_assert(txt7.front() == 'a');
|
||||
static_assert(txt7.back() == 'c');
|
||||
static_assert(txt8.front() == 'a');
|
||||
static_assert(txt8.back() == 'c');
|
||||
static_assert(txt9.front() == 'c');
|
||||
static_assert(txt9.back() == 'a');
|
||||
|
||||
static_assert(std::string_view(txt0.data()) == "");
|
||||
static_assert(std::string_view(txt0.c_str()) == "");
|
||||
static_assert(std::string_view(txt1.data()) == "a");
|
||||
static_assert(std::string_view(txt1.c_str()) == "a");
|
||||
static_assert(std::string_view(txt2.data()) == "abc");
|
||||
static_assert(std::string_view(txt2.c_str()) == "abc");
|
||||
|
||||
static_assert(txt0 == "");
|
||||
static_assert("a" == txt1);
|
||||
static_assert(txt2 == "abc");
|
||||
static_assert(txt3 == "abc");
|
||||
static_assert(txt4 == "abc");
|
||||
static_assert(txt5 == "abc");
|
||||
static_assert(txt6 == "abc");
|
||||
static_assert(txt7 == "abc");
|
||||
static_assert(txt8 == "abc");
|
||||
static_assert(txt9 == "cba");
|
||||
|
||||
static_assert(txt1 == basic_fixed_string("a"));
|
||||
static_assert(txt1 != basic_fixed_string("b"));
|
||||
static_assert(txt1 != basic_fixed_string("aa"));
|
||||
static_assert(txt1 < basic_fixed_string("b"));
|
||||
static_assert(txt1 < basic_fixed_string("aa"));
|
||||
static_assert(txt1 + basic_fixed_string('b') == basic_fixed_string("ab"));
|
||||
static_assert(basic_fixed_string('b') + txt1 == basic_fixed_string("ba"));
|
||||
static_assert(txt1 + basic_fixed_string("bc") == basic_fixed_string("abc"));
|
||||
static_assert(basic_fixed_string("bc") + txt1 == basic_fixed_string("bca"));
|
||||
static_assert(txt1 == "a");
|
||||
static_assert(txt1 != "b");
|
||||
static_assert(txt1 != "aa");
|
||||
static_assert(txt1 < "b");
|
||||
static_assert(txt1 < "aa");
|
||||
|
||||
static_assert(txt1 + basic_fixed_string('b') == "ab");
|
||||
static_assert(basic_fixed_string('b') + txt1 == "ba");
|
||||
static_assert(txt1 + basic_fixed_string("bc") == "abc");
|
||||
static_assert(basic_fixed_string("bc") + txt1 == "bca");
|
||||
static_assert(txt1 + 'b' == "ab");
|
||||
static_assert('b' + txt1 == "ba");
|
||||
static_assert(txt1 + "bc" == "abc");
|
||||
static_assert("bc" + txt1 == "bca");
|
||||
|
||||
constexpr basic_fixed_string txt2("abc");
|
||||
static_assert(txt2.size() == 3);
|
||||
static_assert(txt2[0] == 'a');
|
||||
static_assert(txt2[1] == 'b');
|
||||
static_assert(txt2[2] == 'c');
|
||||
static_assert(txt2 == basic_fixed_string("abc"));
|
||||
static_assert(txt2 != basic_fixed_string("cba"));
|
||||
static_assert(txt2 != basic_fixed_string("abcd"));
|
||||
static_assert(txt2 < basic_fixed_string("b"));
|
||||
static_assert(txt2 > basic_fixed_string("aa"));
|
||||
static_assert(txt2 + basic_fixed_string('d') == basic_fixed_string("abcd"));
|
||||
static_assert(basic_fixed_string('d') + txt2 == basic_fixed_string("dabc"));
|
||||
static_assert(txt2 + basic_fixed_string("def") == basic_fixed_string("abcdef"));
|
||||
static_assert(basic_fixed_string("def") + txt2 == basic_fixed_string("defabc"));
|
||||
static_assert(txt2 == "abc");
|
||||
static_assert(txt2 != "cba");
|
||||
static_assert(txt2 != "abcd");
|
||||
static_assert(txt2 < "b");
|
||||
static_assert(txt2 > "aa");
|
||||
|
||||
#ifndef MP_UNITS_COMP_GCC
|
||||
static_assert(std::string_view(basic_fixed_string("abcd")).find('c') == 2);
|
||||
#endif
|
||||
static_assert(txt2 + basic_fixed_string('d') == "abcd");
|
||||
static_assert(basic_fixed_string('d') + txt2 == "dabc");
|
||||
static_assert(txt2 + basic_fixed_string("def") == "abcdef");
|
||||
static_assert(basic_fixed_string("def") + txt2 == "defabc");
|
||||
static_assert(txt2 + 'd' == "abcd");
|
||||
static_assert('d' + txt2 == "dabc");
|
||||
static_assert(txt2 + "def" == "abcdef");
|
||||
static_assert("def" + txt2 == "defabc");
|
||||
|
||||
static_assert(std::string_view(txt2) == "abc");
|
||||
static_assert(txt2.view() == "abc");
|
||||
static_assert(std::string_view(txt2).find('b') == 1);
|
||||
static_assert(txt2.view().find('b') == 1);
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -20,7 +20,9 @@
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
#include <mp-units/math.h> // IWYU pragma: keep
|
||||
#endif
|
||||
#include <mp-units/systems/iau.h>
|
||||
#include <mp-units/systems/isq/space_and_time.h>
|
||||
#include <mp-units/systems/si.h>
|
||||
@@ -42,7 +44,7 @@ static_assert(isq::length(1 * LD) == 384'399 * si::kilo<si::metre>);
|
||||
static_assert(isq::length(1 * ly) == 9'460'730'472'580'800 * si::metre);
|
||||
static_assert(isq::length(10'000'000'000 * A) == 1 * si::metre);
|
||||
|
||||
#if __cpp_lib_constexpr_cmath || MP_UNITS_COMP_GCC
|
||||
#if MP_UNITS_HOSTED && (__cpp_lib_constexpr_cmath || MP_UNITS_COMP_GCC)
|
||||
// TODO Should the below work for `1 * pc`? If yes, how to extent the type and how to convert it to a floating-point
|
||||
// representation for comparison purposes?
|
||||
static_assert(round<si::metre>(isq::length(1.L * pc)) == 30'856'775'814'913'673 * si::metre);
|
||||
|
||||
@@ -83,7 +83,7 @@ static_assert(Magnitude<decltype(mag<2>)>);
|
||||
static_assert(Magnitude<mag_2_>);
|
||||
|
||||
// is_named_magnitude
|
||||
static_assert(!is_named_magnitude<std::remove_cvref_t<decltype(mag<2>)>>);
|
||||
static_assert(!is_named_magnitude<decltype(mag<2>)>);
|
||||
static_assert(is_named_magnitude<mag_2_>);
|
||||
|
||||
// power_v
|
||||
|
||||
@@ -26,20 +26,25 @@
|
||||
#include <mp-units/systems/isq.h>
|
||||
#include <mp-units/systems/si.h>
|
||||
#include <mp-units/systems/usc.h>
|
||||
#include <chrono>
|
||||
#include <concepts>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#if MP_UNITS_HOSTED
|
||||
#include <chrono>
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
using namespace mp_units;
|
||||
using namespace mp_units::si::unit_symbols;
|
||||
using namespace mp_units::usc::unit_symbols;
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
using namespace std::chrono_literals;
|
||||
using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
|
||||
#endif
|
||||
|
||||
inline constexpr struct zeroth_length : absolute_point_origin<zeroth_length, isq::length> {
|
||||
} zeroth_length;
|
||||
@@ -444,6 +449,7 @@ static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<isq:
|
||||
static_assert(!std::constructible_from<quantity_point<special_height[m]>, quantity<isq::height[m]>>);
|
||||
static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m]>>);
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
// quantity-like
|
||||
static_assert(!std::constructible_from<quantity_point<si::second>, std::chrono::seconds>);
|
||||
static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<si::second>>);
|
||||
@@ -453,7 +459,7 @@ static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<isq::tim
|
||||
|
||||
static_assert(!std::constructible_from<quantity_point<isq::period_duration[s]>, std::chrono::seconds>);
|
||||
static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<isq::period_duration[s]>>);
|
||||
|
||||
#endif
|
||||
|
||||
// ----------------------
|
||||
// explicit point origins
|
||||
@@ -499,6 +505,7 @@ static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<i
|
||||
static_assert(!std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity<isq::length[m]>>);
|
||||
static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<si::metre, mean_sea_level>>);
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
// quantity-like
|
||||
static_assert(!std::constructible_from<quantity_point<si::second, chrono_point_origin<std::chrono::system_clock>>,
|
||||
std::chrono::seconds>);
|
||||
@@ -516,6 +523,7 @@ static_assert(
|
||||
static_assert(
|
||||
!std::convertible_to<std::chrono::seconds,
|
||||
quantity_point<isq::period_duration[s], chrono_point_origin<std::chrono::system_clock>>>);
|
||||
#endif
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
@@ -775,6 +783,7 @@ static_assert(!std::constructible_from<quantity_point<isq::height[m], other_abso
|
||||
static_assert(!std::convertible_to<quantity_point<isq::height[m], ground_level>,
|
||||
quantity_point<isq::height[m], other_absolute_level>>);
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
// quantity-point-like
|
||||
static_assert(
|
||||
std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>, sys_seconds>);
|
||||
@@ -786,6 +795,7 @@ static_assert(
|
||||
!std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::steady_clock>>, sys_seconds>);
|
||||
static_assert(
|
||||
!std::convertible_to<sys_seconds, quantity_point<isq::time[s], chrono_point_origin<std::chrono::steady_clock>>>);
|
||||
#endif
|
||||
|
||||
|
||||
//////////////////////////////////
|
||||
@@ -889,6 +899,7 @@ static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{20 * de
|
||||
static_assert(quantity_point{20 * deg_C}.unit == si::degree_Celsius);
|
||||
static_assert(quantity_point{20 * deg_C}.quantity_spec == kind_of<isq::thermodynamic_temperature>);
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
using namespace std::chrono_literals;
|
||||
static_assert(std::is_same_v<decltype(quantity_point{sys_seconds{123s}})::rep, std::chrono::seconds::rep>);
|
||||
static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{sys_seconds{123s}}.point_origin)>,
|
||||
@@ -897,6 +908,7 @@ static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{sys_sec
|
||||
chrono_point_origin_<std::chrono::system_clock>>);
|
||||
static_assert(quantity_point{sys_seconds{24h}}.unit == si::second);
|
||||
static_assert(quantity_point{sys_seconds{24h}}.quantity_spec == kind_of<isq::time>);
|
||||
#endif
|
||||
|
||||
|
||||
////////////
|
||||
|
||||
@@ -121,10 +121,10 @@ static_assert(!detail::NamedQuantitySpec<decltype(inverse(time))>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<decltype(inverse(time))>);
|
||||
static_assert(!detail::QuantityKindSpec<decltype(inverse(time))>);
|
||||
|
||||
static_assert(QuantitySpec<kind_of_<std::remove_const_t<decltype(length / time)>>>);
|
||||
static_assert(!detail::NamedQuantitySpec<kind_of_<std::remove_const_t<decltype(length / time)>>>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<kind_of_<std::remove_const_t<decltype(length / time)>>>);
|
||||
static_assert(detail::QuantityKindSpec<kind_of_<std::remove_const_t<decltype(length / time)>>>);
|
||||
static_assert(QuantitySpec<kind_of_<decltype(length / time)>>);
|
||||
static_assert(!detail::NamedQuantitySpec<kind_of_<decltype(length / time)>>);
|
||||
static_assert(detail::IntermediateDerivedQuantitySpec<kind_of_<decltype(length / time)>>);
|
||||
static_assert(detail::QuantityKindSpec<kind_of_<decltype(length / time)>>);
|
||||
|
||||
static_assert(QuantitySpec<decltype(kind_of<length> / kind_of<time>)>);
|
||||
static_assert(!detail::NamedQuantitySpec<decltype(kind_of<length> / kind_of<time>)>);
|
||||
|
||||
@@ -27,12 +27,14 @@
|
||||
#include <mp-units/systems/isq/mechanics.h>
|
||||
#include <mp-units/systems/isq/space_and_time.h>
|
||||
#include <mp-units/systems/si.h>
|
||||
#include <chrono>
|
||||
#include <concepts>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#if MP_UNITS_HOSTED
|
||||
#include <chrono>
|
||||
#endif
|
||||
|
||||
template<>
|
||||
inline constexpr bool mp_units::is_vector<int> = true;
|
||||
@@ -311,12 +313,13 @@ static_assert(quantity{123. * m}.quantity_spec == kind_of<isq::length>);
|
||||
static_assert(quantity{123. * h}.unit == si::hour);
|
||||
static_assert(quantity{123. * h}.quantity_spec == kind_of<isq::time>);
|
||||
|
||||
#if MP_UNITS_HOSTED
|
||||
using namespace std::chrono_literals;
|
||||
static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
|
||||
static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
|
||||
static_assert(quantity{24h}.unit == si::hour);
|
||||
static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>);
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////
|
||||
// assignment operator
|
||||
@@ -403,9 +406,6 @@ static_assert((std::uint8_t{255}* m %= 257 * m).numerical_value_in(m) != [] {
|
||||
return ui %= 257;
|
||||
}());
|
||||
|
||||
// TODO ICE
|
||||
// (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
|
||||
#ifndef MP_UNITS_COMP_MSVC
|
||||
// clang-17 with modules build on ignores disabling conversion warnings
|
||||
#if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES)
|
||||
// next two lines trigger conversions warnings
|
||||
@@ -415,7 +415,6 @@ static_assert((22 * m /= 3.33).numerical_value_in(m) == 6);
|
||||
static_assert((22 * m *= 33.33 * one).numerical_value_in(m) == 733);
|
||||
static_assert((22 * m /= 3.33 * one).numerical_value_in(m) == 6);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<template<auto, typename> typename Q>
|
||||
concept invalid_compound_assignments = requires() {
|
||||
@@ -745,6 +744,8 @@ static_assert(4 / (2 * one) == 2 * one);
|
||||
static_assert(4 * one / 2 == 2 * one);
|
||||
static_assert(4 * one % (2 * one) == 0 * one);
|
||||
|
||||
static_assert(2 * rad * (2 * rad) == 4 * pow<2>(rad));
|
||||
|
||||
// modulo arithmetics
|
||||
static_assert(5 * h % (120 * min) == 60 * min);
|
||||
static_assert(300 * min % (2 * h) == 60 * min);
|
||||
@@ -844,8 +845,8 @@ static_assert(10 * isq::mechanical_energy[J] == 5 * isq::force[N] * (2 * isq::le
|
||||
static_assert(1 * si::si2019::speed_of_light_in_vacuum == 299'792'458 * isq::speed[m / s]);
|
||||
|
||||
// Different named dimensions
|
||||
template</*Reference*/ auto R1, /*Reference*/ auto R2> // TODO Use `Reference` when Clang supports it.
|
||||
concept invalid_comparison = !requires { 2 * R1 == 2 * R2; } && !requires { 2 * R2 == 2 * R1; };
|
||||
template<Reference auto R1, Reference auto R2>
|
||||
inline constexpr bool invalid_comparison = !requires { 2 * R1 == 2 * R2; } && !requires { 2 * R2 == 2 * R1; };
|
||||
static_assert(invalid_comparison<isq::activity[Bq], isq::frequency[Hz]>);
|
||||
|
||||
|
||||
|
||||
@@ -98,8 +98,7 @@ static_assert(is_of_type<length[metre], reference<length_, metre_>>);
|
||||
static_assert(is_of_type<kind_of<length>[metre], metre_>);
|
||||
|
||||
static_assert(
|
||||
is_of_type<(length / time)[metre / second],
|
||||
reference<std::remove_const_t<decltype(length / time)>, std::remove_const_t<decltype(metre / second)>>>);
|
||||
is_of_type<(length / time)[metre / second], reference<decltype(length / time), decltype(metre / second)>>);
|
||||
static_assert(is_of_type<(kind_of<length> / kind_of<time>)[metre / second], derived_unit<metre_, per<second_>>>);
|
||||
|
||||
// Unit as a reference
|
||||
|
||||
@@ -57,8 +57,7 @@ static_assert(1 * Qm == 1'000'000'000'000'000'000 * Tm);
|
||||
|
||||
// check for invalid prefixes
|
||||
template<template<typename U> typename prefix, auto V1>
|
||||
concept can_not_be_prefixed =
|
||||
Unit<std::remove_const_t<decltype(V1)>> && !requires { typename prefix<std::remove_const_t<decltype(V1)>>; };
|
||||
concept can_not_be_prefixed = Unit<decltype(V1)> && !requires { typename prefix<decltype(V1)>; };
|
||||
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::degree_Celsius>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::minute>);
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
#include <type_traits>
|
||||
|
||||
template<auto V, typename T>
|
||||
inline constexpr bool is_of_type = std::is_same_v<std::remove_cvref_t<decltype(V)>, T>;
|
||||
inline constexpr bool is_of_type = std::is_same_v<MP_UNITS_REMOVE_CONST(decltype(V)), T>;
|
||||
|
||||
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
|
||||
#ifdef MP_UNITS_API_NO_CRTP
|
||||
|
||||
@@ -210,7 +210,6 @@ static_assert(kilojoule.symbol == "kJ");
|
||||
static_assert(is_of_type<si::kilo<metre>, si::kilo_<metre_>>);
|
||||
static_assert(is_of_type<si::kilo<joule>, si::kilo_<joule_>>);
|
||||
|
||||
// TODO Should the below be a scaled version of metre^2?
|
||||
static_assert(is_of_type<kilometre * metre, derived_unit<kilometre_, metre_>>); // !!!
|
||||
static_assert(is_of_type<kilometre / metre, derived_unit<kilometre_, per<metre_>>>); // !!!
|
||||
|
||||
@@ -241,7 +240,6 @@ static_assert(si::yotta<metre>.symbol == "Ym");
|
||||
static_assert(si::ronna<metre>.symbol == "Rm");
|
||||
static_assert(si::quetta<metre>.symbol == "Qm");
|
||||
|
||||
|
||||
// scaled_unit
|
||||
constexpr auto m_1 = mag<1> * metre;
|
||||
static_assert(is_of_type<m_1, metre_>);
|
||||
|
||||
Reference in New Issue
Block a user