try to fix tests

alifahrri · May 11, 2024 · 0fd5627 · 0fd5627
1 parent 9239805
commit 0fd5627
Show file tree

Hide file tree

Showing 7 changed files with 625 additions and 18 deletions.
diff --git a/include/nmtools/utl/array.hpp b/include/nmtools/utl/array.hpp
@@ -56,6 +56,18 @@ namespace nmtools::utl
             return (size_type)N;
         }
 
+        // The following is intended to enable copy assignment of maybe<array> type in constexpr function/lambda
+        // but then it deprecates the definition of implicit copy constructor
+        #if 0
+        constexpr array& operator=(const array& other) noexcept
+        {
+            for (size_t i=0; i<N; i++) {
+                buffer[i] = other.buffer[i];
+            }
+            return *this;
+        }
+        #endif
+
         constexpr reference operator[](index_type i) noexcept
         {
             return buffer[i];

diff --git a/include/nmtools/utl/either.hpp b/include/nmtools/utl/either.hpp
@@ -38,22 +38,37 @@ namespace nmtools::utl
             return static_cast<const Derived&>(*this);
         }
 
+        constexpr Derived& operator=(const Derived& other) noexcept
+        {
+            if (other.self().tag == Derived::LEFT) {
+                self().left = other.self().left;
+                self().tag  = Derived::LEFT;
+                return self();
+            } else {
+                self().right = other.self().right;
+                self().tag   = Derived::RIGHT;
+                return self();
+            }
+        }
+
         template <typename T>
         constexpr Derived& operator=(const T& val) noexcept
         {
             using left_type  = typename Derived::left_type;
             using right_type = typename Derived::right_type;
-            static_assert( meta::is_same_v<T,left_type> || meta::is_same_v<T,right_type>
+            static_assert( meta::is_same_v<T,left_type> || meta::is_same_v<T,right_type> || meta::is_same_v<T,Derived>
                 , "unsupported type for either assignment"
             );
             if constexpr (meta::is_same_v<T,left_type>) {
                 self().left = val;
                 self().tag  = Derived::LEFT;
                 return self();
-            } else {
+            } else if constexpr (meta::is_same_v<T,right_type>) {
                 self().right = val;
-                self().tag  = Derived::RIGHT;
+                self().tag   = Derived::RIGHT;
                 return self();
+            } else {
+                return operator=(static_cast<Derived>(val));
             }
         }
 
@@ -156,6 +171,11 @@ namespace nmtools::utl
             base::operator=(val);
             return *this;
         }
+
+        constexpr either& operator=(const either& other) noexcept
+        {
+            return base::operator=(other);
+        }
     };
 
     // TODO: find out if we can move the constructor to base for better composition & brevity
@@ -182,6 +202,8 @@ namespace nmtools::utl
         friend struct impl::get_if_t;
         friend base;
     public:
+        using left_type  = left_t;
+        using right_type = right_t;
 
         constexpr either() noexcept
             : left{}, tag{LEFT} {}
@@ -221,8 +243,12 @@ namespace nmtools::utl
         template <typename U>
         constexpr either& operator=(const U& val) noexcept
         {
-            base::operator=(val);
-            return *this;
+            return base::operator=(val);
+        }
+
+        constexpr either& operator=(const either& other) noexcept
+        {
+            return base::operator=(other);
         }
     }; // either
 
@@ -249,6 +275,8 @@ namespace nmtools::utl
         friend struct impl::get_if_t;
         friend base;
     public:
+        using left_type  = left_t;
+        using right_type = right_t;
 
         constexpr either() noexcept
             : left{}, tag{LEFT} {}
@@ -279,8 +307,12 @@ namespace nmtools::utl
         template <typename U>
         constexpr either& operator=(const U& val) noexcept
         {
-            base::operator=(val);
-            return *this;
+            return base::operator=(val);
+        }
+
+        constexpr either& operator=(const either& other) noexcept
+        {
+            return base::operator=(other);
         }
     }; // either
     #endif

diff --git a/include/nmtools/utl/maybe.hpp b/include/nmtools/utl/maybe.hpp
@@ -40,6 +40,8 @@ namespace nmtools::utl
         // assume copy-constructible
         constexpr maybe(const T& t) : base(t) {}
 
+        constexpr maybe(const maybe& other) : base(other) {}
+
         constexpr bool has_value() const noexcept
         {
             return this->tag == base::LEFT;
@@ -56,6 +58,18 @@ namespace nmtools::utl
             return *this;
         }
 
+        /*constexpr*/ maybe& operator=(const maybe& other)
+        {
+            if (other.has_value()) {
+                this->left = other.left;
+                this->tag  = base::LEFT;
+            } else {
+                this->right = other.right;
+                this->tag  = base::RIGHT;
+            }
+            return *this;
+        }
+
         constexpr explicit operator bool() const noexcept
         {
             return has_value();
@@ -135,6 +149,18 @@ namespace nmtools::utl
             return *this;
         }
 
+        /*constexpr*/ maybe& operator=(const maybe& other)
+        {
+            if (other.has_value()) {
+                this->left = other.left;
+                this->tag  = base::LEFT;
+            } else {
+                this->right = other.right;
+                this->tag  = base::RIGHT;
+            }
+            return *this;
+        }
+
         constexpr explicit operator bool() const noexcept
         {
             return has_value();

diff --git a/include/nmtools/utl/vector.hpp b/include/nmtools/utl/vector.hpp
@@ -133,12 +133,25 @@ namespace nmtools::utl
 
         public:
 
-        vector() {}
+        vector()
+            : buffer_(NULL)
+            , size_(0)
+            , buffer_size_(0)
+            , allocator{}
+        {}
         vector(size_type N)
+            : buffer_(NULL)
+            , size_(0)
+            , buffer_size_(0)
+            , allocator{}
         {
             resize(N);
         }
         vector(const vector& other)
+            : buffer_(NULL)
+            , size_(0)
+            , buffer_size_(0)
+            , allocator{}
         {
             resize(other.size_);
             // dumb copy
@@ -154,6 +167,10 @@ namespace nmtools::utl
         // TODO: fix initialization
         template <typename A, typename B, typename...Ts>
         vector(const A& t, const B& u, const Ts&...ts)
+            : buffer_(NULL)
+            , size_(0)
+            , buffer_size_(0)
+            , allocator{}
         {
             constexpr auto n = sizeof...(Ts) + 2;
             resize(n);