diff options
| -rw-r--r-- | doc/src/index.rst | 9 | ||||
| -rw-r--r-- | include/newtype/impl/type_traits_extensions.hpp | 60 | ||||
| -rw-r--r-- | include/newtype/new_type.hpp | 18 | ||||
| -rw-r--r-- | test/src/arithmetic_suite.cpp | 49 |
4 files changed, 135 insertions, 1 deletions
diff --git a/doc/src/index.rst b/doc/src/index.rst index 7f75ec4..18e81f7 100644 --- a/doc/src/index.rst +++ b/doc/src/index.rst @@ -293,6 +293,15 @@ Arithmetic Operators **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is subtractable using the operator :literal:`-` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. +.. cpp:function:: template<typename BaseType, \ + typename TagType, \ + auto DerivationClause> \ + constexpr new_type<BaseType, TagType, DerivationClause> operator*(new_type<BaseType, TagType, DerivationClause> const & lhs, new_type<BaseType, TagType, DerivationClause> const & rhs) + + **noexcept specification:** This input operator shall be noexcept iff. :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is nothrow multipliable as well as nothrow copy-constructible. + + **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is multipliable using the operator :literal:`*` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. + Header :literal:`<newtype/derivable.hpp>` ========================================= diff --git a/include/newtype/impl/type_traits_extensions.hpp b/include/newtype/impl/type_traits_extensions.hpp index e9bbefb..c547d02 100644 --- a/include/newtype/impl/type_traits_extensions.hpp +++ b/include/newtype/impl/type_traits_extensions.hpp @@ -638,6 +638,66 @@ namespace nt::impl template<typename T> auto constexpr is_nothrow_subtractable_v = is_nothrow_subtractable<T>::value; + /** + * @brief A trait to test if a given type is multipliable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-multipliable T + */ + template<typename T, typename = void> + struct is_multipliable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is multipliable + * + * @tparam T The type to test + * @note This specialization forms the case for multipliable T + */ + template<typename T> + struct is_multipliable<T, std::void_t<decltype(std::declval<T const &>() * std::declval<T const &>())>> : std::true_type + { + }; + + /** + * @brief A variable template to test if a given type is multipliable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_multipliable_v = is_multipliable<T>::value; + + /** + * @brief A trait to test if a given type is noexcept multipliable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-noexcept multipliable or non-multipliable T + */ + template<typename T, typename = void> + struct is_nothrow_multipliable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is noexcept multipliable + * + * @tparam T The type to test + * @note This specialization forms the case for multipliable T detemining if T is noexcept multipliable + */ + template<typename T> + struct is_nothrow_multipliable<T, std::void_t<decltype(std::declval<T const &>() * std::declval<T const &>())>> + : std::bool_constant<noexcept(std::declval<T const &>() * std::declval<T const &>())> + { + }; + + /** + * @brief A variable template to test if a given type is noexcept multipliable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_nothrow_multipliable_v = is_nothrow_multipliable<T>::value; } // namespace arithmetic } // namespace nt::impl diff --git a/include/newtype/new_type.hpp b/include/newtype/new_type.hpp index bc8ecee..08d5024 100644 --- a/include/newtype/new_type.hpp +++ b/include/newtype/new_type.hpp @@ -364,6 +364,24 @@ namespace nt return {lhs.decay() - rhs.decay()}; } + /** + * @brief Multiply two instances of the same nt::new_type + * + * @note This operator is only available if the derivation clause of the passed in nt::new_type objects contains nt::Arithmetic and the base + * type is multipliable. + * @param lhs The left-hand side of the multiplication + * @param rhs The right-hand side of the multiplication + * @return a new instance of the same nt::new_type + */ + template<typename BaseType, typename TagType, auto DerivationClause> + auto constexpr + operator*(new_type<BaseType, TagType, DerivationClause> const & lhs, new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept( + impl::is_nothrow_multipliable_v<BaseType> && std::is_nothrow_copy_constructible_v<BaseType>) + -> std::enable_if_t<DerivationClause(nt::Arithmetic) && impl::is_multipliable_v<BaseType>, new_type<BaseType, TagType, DerivationClause>> + { + return {lhs.decay() * rhs.decay()}; + } + } // namespace nt #endif diff --git a/test/src/arithmetic_suite.cpp b/test/src/arithmetic_suite.cpp index b7713e0..e77c1dd 100644 --- a/test/src/arithmetic_suite.cpp +++ b/test/src/arithmetic_suite.cpp @@ -111,7 +111,7 @@ inline namespace subtraction_tests auto subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type() -> void { using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>; - ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() + std::declval<type_alias const &>())>)); + ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() - std::declval<type_alias const &>())>)); } auto subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type() -> void @@ -124,6 +124,45 @@ inline namespace subtraction_tests } // namespace subtraction_tests +inline namespace multiplication_tests +{ + + auto a_new__type_not_deriving_arithmetic_is_not_multipliable_with_instances_of_itself() -> void + { + using type_alias = nt::new_type<int, struct tag>; + ASSERT(!(nt::impl::is_multipliable_v<type_alias>)); + } + + auto a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself() -> void + { + using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>; + ASSERT(nt::impl::is_multipliable_v<type_alias>); + } + + template<typename T> + auto a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable() -> void + { + static_assert(nt::impl::is_multipliable_v<T>, "Sanity Check"); + using type_alias = nt::new_type<T, struct tag, deriving(nt::Arithmetic)>; + ASSERT_EQUAL(nt::impl::is_multipliable_v<T>, nt::impl::is_multipliable_v<type_alias>); + } + + auto multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type() -> void + { + using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>; + ASSERT((std::is_same_v<type_alias, decltype(std::declval<type_alias const &>() * std::declval<type_alias const &>())>)); + } + + auto multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type() -> void + { + using type_alias = nt::new_type<int, struct tag, deriving(nt::Arithmetic)>; + auto lhs = type_alias{24}; + auto rhs = type_alias{18}; + ASSERT_EQUAL(24 * 18, (lhs * rhs).decay()); + } + +} // namespace multiplication_tests + auto arithmetic_suite() -> std::pair<cute::suite, std::string> { return { @@ -143,6 +182,14 @@ auto arithmetic_suite() -> std::pair<cute::suite, std::string> KAWAII(a_new__type_deriving_arithmetic_is_subtractable_with_instances_of_itself_if_the_base_type_is_subtractable<subtractable_type>), KAWAII(subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type), KAWAII(subtraction_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type), + + /// Multiplication Tests + KAWAII(a_new__type_not_deriving_arithmetic_is_not_multipliable_with_instances_of_itself), + KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself), + KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable<int>), + KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable<multipliable_type>), + KAWAII(multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type), + KAWAII(multiplication_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type), }, "Arithmetic Operators Tests"}; }
\ No newline at end of file |