diff options
| -rw-r--r-- | doc/src/index.rst | 11 | ||||
| -rw-r--r-- | include/newtype/impl/type_traits_extensions.hpp | 61 | ||||
| -rw-r--r-- | include/newtype/new_type.hpp | 30 | ||||
| -rw-r--r-- | test/src/arithmetic_suite.cpp | 19 |
4 files changed, 118 insertions, 3 deletions
diff --git a/doc/src/index.rst b/doc/src/index.rst index 4c13412..3ef593d 100644 --- a/doc/src/index.rst +++ b/doc/src/index.rst @@ -327,7 +327,7 @@ Arithmetic Operators **noexcept specification:** This operator shall be noexcept iff. :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is nothrow multiply-assignable. - **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is multiply-assignable using the operator :literal:`-=` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. + **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is multiply-assignable using the operator :literal:`*=` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. .. cpp:function:: template<typename BaseType, \ typename TagType, \ @@ -338,6 +338,15 @@ Arithmetic Operators **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is dividable 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 operator shall be noexcept iff. :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is nothrow divide-assignable. + + **enablement:** This operator shall be available iff. a) :cpp:type:`new_type<BaseType, TagType, DerivationClause>::base_type` is divide-assignable 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 6224d29..10dbc07 100644 --- a/include/newtype/impl/type_traits_extensions.hpp +++ b/include/newtype/impl/type_traits_extensions.hpp @@ -948,6 +948,67 @@ namespace nt::impl template<typename T> auto constexpr is_nothrow_multiply_assignable_v = is_nothrow_multiply_assignable<T>::value; + /** + * @brief A trait to test if a given type is divide-assignable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-divide-assignable T + */ + template<typename T, typename = void> + struct is_divide_assignable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is divide-assignable + * + * @tparam T The type to test + * @note This specialization forms the case for divide-assignable T + */ + template<typename T> + struct is_divide_assignable<T, std::void_t<decltype(std::declval<T &>() /= std::declval<T const &>())>> : std::true_type + { + }; + + /** + * @brief A variable template to test if a given type is divide-assignable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_divide_assignable_v = is_divide_assignable<T>::value; + + /** + * @brief A trait to test if a given type is noexcept divide-assignable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-noexcept divide-assignable or non-divide-assignable T + */ + template<typename T, typename = void> + struct is_nothrow_divide_assignable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is noexcept divide-assignable + * + * @tparam T The type to test + * @note This specialization forms the case for divide-assignable T detemining if T is noexcept divide-assignable + */ + template<typename T> + struct is_nothrow_divide_assignable<T, std::void_t<decltype(std::declval<T &>() /= std::declval<T const &>())>> + : std::bool_constant<noexcept(std::declval<T &>() /= std::declval<T const &>())> + { + }; + + /** + * @brief A variable template to test if a given type is noexcept divide-assignable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_nothrow_divide_assignable_v = is_nothrow_divide_assignable<T>::value; + } // namespace compound_arithmetic } // namespace nt::impl diff --git a/include/newtype/new_type.hpp b/include/newtype/new_type.hpp index a7ab4af..d22732a 100644 --- a/include/newtype/new_type.hpp +++ b/include/newtype/new_type.hpp @@ -57,6 +57,13 @@ namespace nt -> std::enable_if_t<DerivationClauseV(nt::Arithmetic) && impl::is_multiply_assignable_v<BaseTypeT>, new_type<BaseTypeT, TagTypeT, DerivationClauseV> &>; + template<typename BaseTypeT, typename TagTypeT, auto DerivationClauseV> + auto constexpr friend + operator/=(new_type<BaseTypeT, TagTypeT, DerivationClauseV> & lhs, + new_type<BaseTypeT, TagTypeT, DerivationClauseV> const & rhs) noexcept(impl::is_nothrow_divide_assignable_v<BaseTypeT>) + -> std::enable_if_t<DerivationClauseV(nt::Arithmetic) && impl::is_divide_assignable_v<BaseTypeT>, + new_type<BaseTypeT, TagTypeT, DerivationClauseV> &>; + using super = impl::new_type_move_assignment<BaseType, TagType>; public: @@ -447,8 +454,8 @@ namespace nt * * @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 multiplyable. - * @param lhs The left-hand side of the multiplyition - * @param rhs The right-hand side of the multiplyition + * @param lhs The left-hand side of the multiplication + * @param rhs The right-hand side of the multiplication * @return a reference to the the modified value */ template<typename BaseType, typename TagType, auto DerivationClause> @@ -480,6 +487,25 @@ namespace nt return {lhs.decay() / rhs.decay()}; } + /** + * @brief Divide two instances of the same nt::new_type, modifying the left-hand side + * + * @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 dividable. + * @param lhs The left-hand side of the division + * @param rhs The right-hand side of the division + * @return a reference to the the modified value + */ + template<typename BaseType, typename TagType, auto DerivationClause> + auto constexpr operator/=(new_type<BaseType, TagType, DerivationClause> & lhs, + new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(impl::is_nothrow_divide_assignable_v<BaseType>) + -> std::enable_if_t<DerivationClause(nt::Arithmetic) && impl::is_divide_assignable_v<BaseType>, + new_type<BaseType, TagType, DerivationClause> &> + { + lhs.m_value /= rhs.m_value; + return lhs; + } + } // namespace nt #endif diff --git a/test/src/arithmetic_suite.cpp b/test/src/arithmetic_suite.cpp index c7051e2..f831b98 100644 --- a/test/src/arithmetic_suite.cpp +++ b/test/src/arithmetic_suite.cpp @@ -256,6 +256,23 @@ inline namespace compound_arithmetic ASSERT_EQUAL(elhs *= erhs, (lhs *= rhs).decay()); } + auto division_assignment_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 &>() /= std::declval<type_alias const &>())>)); + } + + auto division_assignment_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 elhs = 42; + auto erhs = 18; + auto lhs = type_alias{elhs}; + auto rhs = type_alias{erhs}; + ASSERT_EQUAL(elhs /= erhs, (lhs /= rhs).decay()); + } + } // namespace compound_arithmetic auto arithmetic_suite() -> std::pair<cute::suite, std::string> @@ -303,6 +320,8 @@ auto arithmetic_suite() -> std::pair<cute::suite, std::string> KAWAII(subtraction_assignment_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type), KAWAII(multiplication_assignment_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type), KAWAII(multiplication_assignment_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type), + KAWAII(division_assignment_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type), + KAWAII(division_assignment_of_two_instances_of_a_new__type_deriving_arithmetic_produces_the_correct_value_with_respect_to_the_base_type), // clang-format on }, |