From b34cbb0fa7dcd783245d2d2b2352846579bbb77b Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Thu, 2 Jan 2020 12:56:56 +0100 Subject: new_type: implement division --- doc/src/index.rst | 16 +++++-- include/newtype/impl/type_traits_extensions.hpp | 62 +++++++++++++++++++++++++ include/newtype/new_type.hpp | 18 +++++++ test/src/arithmetic_suite.cpp | 47 +++++++++++++++++++ 4 files changed, 140 insertions(+), 3 deletions(-) diff --git a/doc/src/index.rst b/doc/src/index.rst index 18e81f7..e8647c1 100644 --- a/doc/src/index.rst +++ b/doc/src/index.rst @@ -280,7 +280,7 @@ Arithmetic Operators auto DerivationClause> \ constexpr new_type operator+(new_type const & lhs, new_type const & rhs) - **noexcept specification:** This input operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow addable as well as nothrow copy-constructible. + **noexcept specification:** This operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow addable as well as nothrow copy-constructible. **enablement:** This operator shall be available iff. a) :cpp:type:`new_type::base_type` is addable using the operator :literal:`+` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. @@ -289,7 +289,7 @@ Arithmetic Operators auto DerivationClause> \ constexpr new_type operator-(new_type const & lhs, new_type const & rhs) - **noexcept specification:** This input operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow subtractable as well as nothrow copy-constructible. + **noexcept specification:** This operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow subtractable as well as nothrow copy-constructible. **enablement:** This operator shall be available iff. a) :cpp:type:`new_type::base_type` is subtractable using the operator :literal:`-` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. @@ -298,10 +298,20 @@ Arithmetic Operators auto DerivationClause> \ constexpr new_type operator*(new_type const & lhs, new_type const & rhs) - **noexcept specification:** This input operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow multipliable as well as nothrow copy-constructible. + **noexcept specification:** This operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow multipliable as well as nothrow copy-constructible. **enablement:** This operator shall be available iff. a) :cpp:type:`new_type::base_type` is multipliable using the operator :literal:`*` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. + +.. cpp:function:: template \ + constexpr new_type operator/(new_type const & lhs, new_type const & rhs) + + **noexcept specification:** This operator shall be noexcept iff. :cpp:type:`new_type::base_type` is nothrow dividable as well as nothrow copy-constructible. + + **enablement:** This operator shall be available iff. a) :cpp:type:`new_type::base_type` is dividable using the operator :literal:`/` and b) :cpp:type:`DerivationClause` includes :cpp:var:`Arithmetic`. + Header :literal:`` ========================================= diff --git a/include/newtype/impl/type_traits_extensions.hpp b/include/newtype/impl/type_traits_extensions.hpp index c547d02..f9cd51a 100644 --- a/include/newtype/impl/type_traits_extensions.hpp +++ b/include/newtype/impl/type_traits_extensions.hpp @@ -698,6 +698,68 @@ namespace nt::impl */ template auto constexpr is_nothrow_multipliable_v = is_nothrow_multipliable::value; + + /** + * @brief A trait to test if a given type is dividable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-dividable T + */ + template + struct is_dividable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is dividable + * + * @tparam T The type to test + * @note This specialization forms the case for dividable T + */ + template + struct is_dividable() / std::declval())>> : std::true_type + { + }; + + /** + * @brief A variable template to test if a given type is dividable + * + * @tparam T The type to test + */ + template + auto constexpr is_dividable_v = is_dividable::value; + + /** + * @brief A trait to test if a given type is noexcept dividable + * + * @tparam T The type to test + * @note This specialization forms the base case for non-noexcept dividable or non-dividable T + */ + template + struct is_nothrow_dividable : std::false_type + { + }; + + /** + * @brief A trait to test if a given type is noexcept dividable + * + * @tparam T The type to test + * @note This specialization forms the case for dividable T detemining if T is noexcept dividable + */ + template + struct is_nothrow_dividable() / std::declval())>> + : std::bool_constant() / std::declval())> + { + }; + + /** + * @brief A variable template to test if a given type is noexcept dividable + * + * @tparam T The type to test + */ + template + auto constexpr is_nothrow_dividable_v = is_nothrow_dividable::value; + } // namespace arithmetic } // namespace nt::impl diff --git a/include/newtype/new_type.hpp b/include/newtype/new_type.hpp index 08d5024..59e0b1a 100644 --- a/include/newtype/new_type.hpp +++ b/include/newtype/new_type.hpp @@ -382,6 +382,24 @@ namespace nt return {lhs.decay() * rhs.decay()}; } + /** + * @brief Divide 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 dividable. + * @param lhs The left-hand side of the division + * @param rhs The right-hand side of the division + * @return a new instance of the same nt::new_type + */ + template + auto constexpr + operator/(new_type const & lhs, new_type const & rhs) noexcept( + impl::is_nothrow_dividable_v && std::is_nothrow_copy_constructible_v) + -> std::enable_if_t, new_type> + { + return {lhs.decay() / rhs.decay()}; + } + } // namespace nt #endif diff --git a/test/src/arithmetic_suite.cpp b/test/src/arithmetic_suite.cpp index e77c1dd..7c2b617 100644 --- a/test/src/arithmetic_suite.cpp +++ b/test/src/arithmetic_suite.cpp @@ -163,6 +163,45 @@ inline namespace multiplication_tests } // namespace multiplication_tests +inline namespace division_tests +{ + + auto a_new__type_not_deriving_arithmetic_is_not_dividable_with_instances_of_itself() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::is_dividable_v)); + } + + auto a_new__type_deriving_arithmetic_is_dividable_with_instances_of_itself() -> void + { + using type_alias = nt::new_type; + ASSERT(nt::impl::is_dividable_v); + } + + template + auto a_new__type_deriving_arithmetic_is_dividable_with_instances_of_itself_if_the_base_type_is_dividable() -> void + { + static_assert(nt::impl::is_dividable_v, "Sanity Check"); + using type_alias = nt::new_type; + ASSERT_EQUAL(nt::impl::is_dividable_v, nt::impl::is_dividable_v); + } + + auto division_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type() -> void + { + using type_alias = nt::new_type; + ASSERT((std::is_same_v() / std::declval())>)); + } + + auto division_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; + auto lhs = type_alias{24}; + auto rhs = type_alias{2}; + ASSERT_EQUAL(24 / 2, (lhs / rhs).decay()); + } + +} // namespace division_tests + auto arithmetic_suite() -> std::pair { return { @@ -190,6 +229,14 @@ auto arithmetic_suite() -> std::pair KAWAII(a_new__type_deriving_arithmetic_is_multipliable_with_instances_of_itself_if_the_base_type_is_multipliable), 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), + + /// Division Tests + KAWAII(a_new__type_not_deriving_arithmetic_is_not_dividable_with_instances_of_itself), + KAWAII(a_new__type_deriving_arithmetic_is_dividable_with_instances_of_itself), + KAWAII(a_new__type_deriving_arithmetic_is_dividable_with_instances_of_itself_if_the_base_type_is_dividable), + KAWAII(a_new__type_deriving_arithmetic_is_dividable_with_instances_of_itself_if_the_base_type_is_dividable), + KAWAII(division_of_two_instances_of_a_new__type_deriving_arithmetic_produces_an_instance_of_the_same_new__type), + KAWAII(division_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 -- cgit v1.2.3