feat: freestanding support added

Resolves #564, #565, and #556

test/CMakeLists.txt

@@ -22,5 +22,7 @@
 
 cmake_minimum_required(VERSION 3.5)
 
-add_subdirectory(runtime)
+if(!${projectPrefix}API_FREESTANDING)
+    add_subdirectory(runtime)
+endif()
 add_subdirectory(static)

test/static/CMakeLists.txt

@@ -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
@@ -64,6 +61,11 @@ add_library(
     unit_symbol_test.cpp
     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)

test/static/concepts_test.cpp

@@ -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 {
 
@@ -157,7 +161,9 @@ 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>);
@@ -181,7 +187,9 @@ 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>);
@@ -205,7 +213,9 @@ 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>);
@@ -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>);
@@ -284,27 +296,33 @@ static_assert(!ReferenceOf<std::remove_const_t<decltype(dimensionless[one])>, is
 // 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])>>);
 
@@ -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>);
@@ -349,8 +369,10 @@ static_assert(!QuantityPoint<std::remove_const_t<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
@@ -384,8 +406,10 @@ 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])>>);
+#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
@@ -408,13 +432,17 @@ static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative
 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>);
+#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>);

test/static/fixed_string_test.cpp

@@ -31,12 +31,12 @@ namespace {
 constexpr std::array array = {'a', 'b', 'c'};
 
 auto from_string = [] {
-  std::string txt = "abc";
+  std::string_view txt = "abc";
   return fixed_string<3>(std::from_range, txt);
 };
 
 auto from_string_iter = [] {
-  std::string txt = "abc";
+  std::string_view txt = "abc";
   return fixed_string<3>(txt.begin(), txt.end());
 };
 
@@ -90,6 +90,7 @@ 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');
@@ -97,6 +98,7 @@ 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');

test/static/iau_test.cpp

@@ -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);

test/static/quantity_point_test.cpp

@@ -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
 
 
 ////////////

test/static/quantity_test.cpp

@@ -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