feat: Add option_t

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

include/cmcpp/lift.hpp

@@ -45,6 +45,9 @@ namespace cmcpp
     template <Variant T>
     inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
 
+    template <Option T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
 }
 
 #endif

include/cmcpp/lower.hpp

@@ -61,6 +61,8 @@ namespace cmcpp
     template <Variant T>
     inline WasmValVector lower_flat(CallContext &cx, const T &v);
 
+    template <Option T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v);
 }
 
 #endif

include/cmcpp/traits.hpp

@@ -148,7 +148,7 @@ namespace cmcpp
     {
         static_assert(false, "T is not a valid type for ValTrait. Type: ");
         static constexpr ValType type = ValType::UNKNOWN;
-        using inner_type = void;
+        using inner_type = std::monostate;
         static constexpr uint32_t size = 0;
         static constexpr uint32_t alignment = 0;
         static constexpr std::array<WasmValType, 0> flat_types = {};
@@ -675,7 +675,20 @@ namespace cmcpp
     template <typename T>
     concept Variant = ValTrait<T>::type == ValType::Variant;
 
-    //  Other  --------------------------------------------------------------------
+    //  Option  --------------------------------------------------------------------
+    template <Field T>
+    using option_t = std::optional<T>;
+    template <Field T>
+    struct ValTrait<option_t<T>>
+    {
+        static constexpr ValType type = ValType::Option;
+        using inner_type = T;
+        static constexpr uint32_t size = ValTrait<variant_t<bool_t, T>>::size;
+        static constexpr uint32_t alignment = ValTrait<variant_t<bool_t, T>>::size;
+        static constexpr auto flat_types = ValTrait<variant_t<bool_t, T>>::flat_types;
+    };
+    template <typename T>
+    concept Option = ValTrait<T>::type == ValType::Option;
 
     //  --------------------------------------------------------------------
 

include/cmcpp/variant.hpp

@@ -87,7 +87,7 @@ namespace cmcpp
         };
 
         template <Variant T>
-        WasmValVector lower_flat_variant(CallContext &cx, const T &v)
+        WasmValVector lower_flat(CallContext &cx, const T &v)
         {
             auto case_index = v.index();
             WasmValTypeVector flat_types(ValTrait<T>::flat_types.begin(), ValTrait<T>::flat_types.end());
@@ -180,7 +180,22 @@ namespace cmcpp
     template <Variant T>
     inline WasmValVector lower_flat(CallContext &cx, const T &v)
     {
-        return variant::lower_flat_variant(cx, v);
+        return variant::lower_flat(cx, v);
+    }
+
+    template <Option T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v)
+    {
+        using V = variant_t<bool_t, typename ValTrait<T>::inner_type>;
+        if (v.has_value())
+        {
+            V v2 = v.value();
+            return variant::lower_flat(cx, v2);
+        }
+        else
+        {
+            return variant::lower_flat<V>(cx, false);
+        }
     }
 
     template <Variant T>
@@ -195,6 +210,19 @@ namespace cmcpp
         return variant::lift_flat<T>(cx, vi);
     }
 
+    template <Option T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
+    {
+        T retVal;
+        using V = variant_t<bool_t, typename ValTrait<T>::inner_type>;
+        auto v = variant::lift_flat<V>(cx, vi);
+        if (v.index() == 1)
+        {
+            retVal = std::get<1>(v);
+        }
+        return retVal;
+    }
+
 }
 
 #endif

test/main.cpp

@@ -491,6 +491,12 @@ TEST_CASE("Variant")
     Heap heap(1024 * 1024);
     auto cx = createCallContext(&heap, Encoding::Utf8);
 
+    using Vb = variant_t<bool_t, uint32_t>;
+    Vb vb = static_cast<uint32_t>(42);
+    auto vvb = lower_flat(*cx, vb);
+    auto vbb = lift_flat<Vb>(*cx, vvb);
+    CHECK(vb == vbb);
+
     using V0 = variant_t<uint16_t, uint32_t>;
     auto x = ValTrait<ValTrait<V0>::discriminant_type>::size;
     V0 v0 = static_cast<uint32_t>(42);
@@ -559,3 +565,31 @@ TEST_CASE("Variant")
     auto v88 = lift_flat<VariantList4>(*cx, vv8);
     CHECK(variants4 == v88);
 }
+
+TEST_CASE("Option")
+{
+    Heap heap(1024 * 1024);
+    auto cx = createCallContext(&heap, Encoding::Utf8);
+
+    using O0 = option_t<uint32_t>;
+    O0 o0 = 42;
+    auto vv0 = lower_flat(*cx, o0);
+    auto v00 = lift_flat<O0>(*cx, vv0);
+    CHECK(o0 == v00);
+
+    O0 o1;
+    auto vv1 = lower_flat(*cx, o1);
+    auto v01 = lift_flat<O0>(*cx, vv1);
+    CHECK(o1 == v01);
+
+    using O1 = option_t<string_t>;
+    O1 o2 = "Hello";
+    auto vv2 = lower_flat(*cx, o2);
+    auto v02 = lift_flat<O1>(*cx, vv2);
+    CHECK(o2 == v02);
+
+    O1 o3;
+    auto vv3 = lower_flat(*cx, o3);
+    auto v03 = lift_flat<O1>(*cx, vv3);
+    CHECK(o3 == v03);
+}