[expected] fix move ctor of <void, E>, add emplace to all

Author: iboB

include/itlib/expected.hpp

@@ -1,4 +1,4 @@
-// itlib-expected v1.03
+// itlib-expected v1.04
 //
 // A union-type of a value and an error
 //
@@ -28,6 +28,8 @@
 //
 //                  VERSION HISTORY
 //
+//  1.04 (2025-04-03) - Fix move assign in <void, E> specialization
+//                    - Add emplace for all specializations
 //  1.03 (2025-01-23) Add value and error "getters" in void specializations
 //  1.02 (2022-09-02) Specializations for ref and void values and void errors
 //  1.01 (2021-09-27) Fixed value_or which could return a ref to temporary
@@ -198,11 +200,11 @@ class expected
     {
         if (m_has_value)
         {
-            new (&m_value) T(std::move(other.m_value));
+            ::new (&m_value) T(std::move(other.m_value));
         }
         else
         {
-            new (&m_error) E(std::move(other.m_error));
+            ::new (&m_error) E(std::move(other.m_error));
         }
     }
 
@@ -243,6 +245,22 @@ class expected
         }
     }
 
+    template <typename... Args>
+    T& emplace(Args&&... args)
+    {
+        if (m_has_value)
+        {
+            m_value.~T();
+        }
+        else
+        {
+            m_error.~E();
+        }
+        ::new (&m_value) T(std::forward<Args>(args)...);
+        m_has_value = true;
+        return m_value;
+    }
+
     // bool interface
     bool has_value() const { return m_has_value; }
     bool has_error() const { return !m_has_value; }
@@ -366,6 +384,16 @@ class expected<T&, E> {
         }
     }
 
+    T& emplace(T& t)
+    {
+        if (!m_value)
+        {
+            m_error.~E();
+        }
+        m_value = &t;
+        return t;
+    }
+
     // bool interface
     bool has_value() const { return !!m_value; }
     bool has_error() const { return !m_value; }
@@ -447,10 +475,11 @@ class expected<void, E> {
             m_has_value = true;
             m_error.~E();
         }
-        else
+        else if (!m_has_value && !other.has_value())
         {
             m_error = std::move(other.m_error);
         }
+        // else nothing to do
         return *this;
     }
 
@@ -462,6 +491,15 @@ class expected<void, E> {
         }
     }
 
+    void emplace()
+    {
+        if (!m_has_value)
+        {
+            m_error.~E();
+        }
+        m_has_value = true;
+    }
+
     // bool interface
     bool has_value() const { return m_has_value; }
     bool has_error() const { return !m_has_value; }
@@ -517,7 +555,7 @@ class expected<T, void>
     {
         if (m_has_value)
         {
-            new (&m_value) T(other.m_value);
+            ::new (&m_value) T(other.m_value);
         }
     }
     expected& operator=(const expected& other)
@@ -544,7 +582,7 @@ class expected<T, void>
     {
         if (m_has_value)
         {
-            new (&m_value) T(std::move(other.m_value));
+            ::new (&m_value) T(std::move(other.m_value));
         }
     }
 
@@ -588,11 +626,12 @@ class expected<T, void>
         m_has_value = false;
     }
     template <typename... Args>
-    void emplace(Args&&... args)
+    T& emplace(Args&&... args)
     {
         clear();
         ::new (&m_value) T(std::forward<Args>(args)...);
         m_has_value = true;
+        return m_value;
     }
 
     // value getters
@@ -661,7 +700,11 @@ class expected<T&, void> {
 
     // optional interface
     void clear() { m_value = nullptr; }
-    void emplace(T& t) { m_value = &t; }
+    T& emplace(T& t)
+    {
+        m_value = &t;
+        return t;
+    }
 
     // value getters (pointer semantics)
     T& value() const

test/t-expected-11.cpp

@@ -220,6 +220,23 @@ TEST_CASE("lifetime")
         CHECK(vs.living == 1);
     }
 
+    // error to value 2
+    {
+        value::lifetime_stats vs;
+        error::lifetime_stats es;
+        auto x = func(false);
+        auto& ref = x.emplace(8);
+        CHECK(ref.val == 8);
+        CHECK(x.has_value());
+        CHECK(es.d_ctr == 1);
+        CHECK(es.total == 1);
+        CHECK(es.living == 0);
+        CHECK(vs.d_ctr == 1);
+        CHECK(vs.m_ctr == 0);
+        CHECK(vs.total == 1);
+        CHECK(vs.living == 1);
+    }
+
     // value to error
     {
         value::lifetime_stats vs;
@@ -235,6 +252,20 @@ TEST_CASE("lifetime")
         CHECK(es.total == 2);
         CHECK(es.living == 1);
     }
+
+    // value to value
+    {
+        value::lifetime_stats vs;
+        error::lifetime_stats es;
+        auto x = func(true);
+        auto& ref = x.emplace(105);
+        CHECK(ref.val == 105);
+        CHECK(x.has_value());
+        CHECK(vs.d_ctr == 2);
+        CHECK(vs.total == 2);
+        CHECK(vs.living == 1);
+        CHECK(es.checkpoint() == empty);
+    }
 }
 
 struct obj {
@@ -374,6 +405,25 @@ TEST_CASE("ref lifetime")
         CHECK(vs.living == 1);
     }
 
+    // error to value 2
+    {
+        value::lifetime_stats vs;
+        error::lifetime_stats es;
+        const obj o;
+
+        auto x = o.ie();
+        value v;
+        auto& ref = x.emplace(v);
+        CHECK(&ref == &v);
+
+        CHECK(x.has_value());
+        CHECK(es.d_ctr == 1);
+        CHECK(es.total == 1);
+        CHECK(es.living == 0);
+        CHECK(vs.total == 2);
+        CHECK(vs.living == 2);
+    }
+
     // value to error
     {
         value::lifetime_stats vs;
@@ -420,6 +470,9 @@ TEST_CASE("void basic")
     CHECK(!v);
     REQUIRE(v.has_error());
     CHECK(v.error().err == 1);
+
+    v.emplace();
+    CHECK(v.has_value());
 }
 
 TEST_CASE("void lifetime")
@@ -443,23 +496,23 @@ TEST_CASE("void lifetime")
     {
         error::lifetime_stats es;
 
-        const auto x = func(true);
+        const auto x = vfunc(true);
         CHECK(es.checkpoint() == empty);
     }
 
     {
         error::lifetime_stats es;
 
-        auto x = func(false);
-        x = func(false);
+        auto x = vfunc(false);
+        x = vfunc(false);
         REQUIRE(x.has_error());
         CHECK(x.error().err == 1);
         CHECK(es.d_ctr == 2);
         CHECK(es.m_ctr == 0);
         CHECK(es.m_asgn == 1);
         CHECK(es.living == 1);
 
-        auto e = func(false).error();
+        auto e = vfunc(false).error();
         CHECK(es.d_ctr == 3);
         CHECK(es.m_ctr == 1);
         CHECK(es.m_asgn == 1);
@@ -470,8 +523,8 @@ TEST_CASE("void lifetime")
     {
         error::lifetime_stats es;
 
-        auto x = func(true);
-        x = func(true);
+        auto x = vfunc(true);
+        x = vfunc(true);
         CHECK(es.checkpoint() == empty);
     }
 
@@ -487,6 +540,17 @@ TEST_CASE("void lifetime")
         CHECK(es.living == 0);
     }
 
+    // error to value 2
+    {
+        error::lifetime_stats es;
+        auto x = func(false);
+        x.emplace();
+        CHECK(x.has_value());
+        CHECK(es.d_ctr == 1);
+        CHECK(es.total == 1);
+        CHECK(es.living == 0);
+    }
+
     // value to error
     {
         error::lifetime_stats es;
@@ -530,10 +594,13 @@ TEST_CASE("eoptional")
     CHECK(io.value_or(44) == 44);
     io.error(); // should compile and safely do nothing
 
-    io.emplace(5);
+    auto& ref = io.emplace(5);
     CHECK(io);
     CHECK(*io == 5);
     CHECK(io.value_or(44) == 5);
+    CHECK(ref == 5);
+    ref = 10;
+    CHECK(io.value_or(44) == 10);
 }
 
 TEST_CASE("eoptional ref")
@@ -564,10 +631,13 @@ TEST_CASE("eoptional ref")
     CHECK(io.value_or(44) == 44);
 
     int i = 34;
-    io.emplace(i);
+    auto& ref = io.emplace(i);
     CHECK(io);
     CHECK(*io == 34);
     CHECK(&io.value() == &i);
+    CHECK(ref == 34);
+    i = 10;
+    CHECK(ref == 10);
 }
 
 TEST_CASE("eoptional void")