diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/newtype/impl/type_traits_extensions.hpp | 62 | ||||
| -rw-r--r-- | include/newtype/new_type.hpp | 18 |
2 files changed, 80 insertions, 0 deletions
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<typename T> auto constexpr is_nothrow_multipliable_v = is_nothrow_multipliable<T>::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<typename T, typename = void> + 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<typename T> + struct is_dividable<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 dividable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_dividable_v = is_dividable<T>::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<typename T, typename = void> + 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<typename T> + struct is_nothrow_dividable<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 dividable + * + * @tparam T The type to test + */ + template<typename T> + auto constexpr is_nothrow_dividable_v = is_nothrow_dividable<T>::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<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_dividable_v<BaseType> && std::is_nothrow_copy_constructible_v<BaseType>) + -> std::enable_if_t<DerivationClause(nt::Arithmetic) && impl::is_dividable_v<BaseType>, new_type<BaseType, TagType, DerivationClause>> + { + return {lhs.decay() / rhs.decay()}; + } + } // namespace nt #endif |