From 9a5d11d4c5701c8ad2e6aa1213cc9fd2937ccbc4 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@gmail.com>
Date: Thu, 2 Jan 2020 13:15:53 +0100
Subject: new_type: implement add-assign

---
 include/newtype/impl/type_traits_extensions.hpp | 249 ++++++++++++++++++++++++
 include/newtype/new_type.hpp                    |  26 +++
 2 files changed, 275 insertions(+)

(limited to 'include')

diff --git a/include/newtype/impl/type_traits_extensions.hpp b/include/newtype/impl/type_traits_extensions.hpp
index f9cd51a..8935a4e 100644
--- a/include/newtype/impl/type_traits_extensions.hpp
+++ b/include/newtype/impl/type_traits_extensions.hpp
@@ -762,6 +762,255 @@ namespace nt::impl
 
   }  // namespace arithmetic
 
+  inline namespace compound_arithmetic
+  {
+
+    /**
+     * @brief A trait to test if a given type is add-assignable
+     *
+     * @tparam T The type to test
+     * @note This specialization forms the base case for non-add-assignable T
+     */
+    template<typename T, typename = void>
+    struct is_add_assignable : std::false_type
+    {
+    };
+
+    /**
+     * @brief A trait to test if a given type is add-assignable
+     *
+     * @tparam T The type to test
+     * @note This specialization forms the case for add-assignable T
+     */
+    template<typename T>
+    struct is_add_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 add-assignable
+     *
+     * @tparam T The type to test
+     */
+    template<typename T>
+    auto constexpr is_add_assignable_v = is_add_assignable<T>::value;
+
+    /**
+     * @brief A trait to test if a given type is noexcept add-assignable
+     *
+     * @tparam T The type to test
+     * @note This specialization forms the base case for non-noexcept add-assignable or non-add-assignable T
+     */
+    template<typename T, typename = void>
+    struct is_nothrow_add_assignable : std::false_type
+    {
+    };
+
+    /**
+     * @brief A trait to test if a given type is noexcept add-assignable
+     *
+     * @tparam T The type to test
+     * @note This specialization forms the case for add-assignable T detemining if T is noexcept add-assignable
+     */
+    template<typename T>
+    struct is_nothrow_add_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 add-assignable
+     *
+     * @tparam T The type to test
+     */
+    template<typename T>
+    auto constexpr is_nothrow_add_assignable_v = is_nothrow_add_assignable<T>::value;
+
+    // /**
+    //  * @brief A trait to test if a given type is subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  * @note This specialization forms the base case for non-subtractable T
+    //  */
+    // template<typename T, typename = void>
+    // struct is_subtract_assignable : std::false_type
+    // {
+    // };
+
+    // /**
+    //  * @brief A trait to test if a given type is subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  * @note This specialization forms the case for subtractable T
+    //  */
+    // template<typename T>
+    // struct is_subtract_assignable<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 subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  */
+    // template<typename T>
+    // auto constexpr is_subtractable_v = is_subtract_assignable<T>::value;
+
+    // /**
+    //  * @brief A trait to test if a given type is noexcept subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  * @note This specialization forms the base case for non-noexcept subtractable or non-subtractable T
+    //  */
+    // template<typename T, typename = void>
+    // struct is_nothrow_subtractable : std::false_type
+    // {
+    // };
+
+    // /**
+    //  * @brief A trait to test if a given type is noexcept subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  * @note This specialization forms the case for subtractable T detemining if T is noexcept subtractable
+    //  */
+    // template<typename T>
+    // struct is_nothrow_subtractable<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 subtractable
+    //  *
+    //  * @tparam T The type to test
+    //  */
+    // 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;
+
+    // /**
+    //  * @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 compound_arithmetic
+
 }  // namespace nt::impl
 
 #endif
\ No newline at end of file
diff --git a/include/newtype/new_type.hpp b/include/newtype/new_type.hpp
index 59e0b1a..3f9fdea 100644
--- a/include/newtype/new_type.hpp
+++ b/include/newtype/new_type.hpp
@@ -36,6 +36,13 @@ namespace nt
         -> std::enable_if_t<DerivationClauseV(nt::Read) && impl::is_input_streamable_v<std::basic_istream<CharType, StreamTraits>, BaseTypeT>,
                             std::basic_istream<CharType, StreamTraits>> &;
 
+    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_add_assignable_v<BaseTypeT>)
+        -> std::enable_if_t<DerivationClauseV(nt::Arithmetic) && impl::is_add_assignable_v<BaseTypeT>,
+                            new_type<BaseTypeT, TagTypeT, DerivationClauseV> &>;
+
     using super = impl::new_type_move_assignment<BaseType, TagType>;
 
   public:
@@ -346,6 +353,25 @@ namespace nt
     return {lhs.decay() + rhs.decay()};
   }
 
+  /**
+   * @brief Add 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 addable.
+   * @param lhs The left-hand side of the addition
+   * @param rhs The right-hand side of the addition
+   * @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_add_assignable_v<BaseType>)
+      -> std::enable_if_t<DerivationClause(nt::Arithmetic) && impl::is_add_assignable_v<BaseType>,
+                          new_type<BaseType, TagType, DerivationClause> &>
+  {
+    lhs.m_value += rhs.decay();
+    return lhs;
+  }
+
   /**
    * @brief Subtract two instances of the same nt::new_type
    *
-- 
cgit v1.2.3