CDK: foundation: introduce cdk::opt<> template and fix copy semantics for cdk::variant<>.

Author: rsomla1

cdk/include/mysql/cdk/foundation.h

@@ -46,6 +46,8 @@ namespace cdk {
   using foundation::string;
   using foundation::scoped_ptr;
   using foundation::shared_ptr;
+  using foundation::variant;
+  using foundation::opt;
 
   using foundation::bytes;
   using foundation::buffers;

cdk/include/mysql/cdk/foundation/variant.h

@@ -103,13 +103,13 @@ class variant_base<Size, Align, First, Rest...>
   variant_base(const First &val)
     : m_owns(true)
   {
-    new (&m_storage) First(val);
+    set(val);
   }
 
   variant_base(First &&val)
     : m_owns(true)
   {
-    new (&m_storage) First(std::move(val));
+    set(std::move(val));
   }
 
   template<typename T>
@@ -132,17 +132,24 @@ class variant_base<Size, Align, First, Rest...>
   {
     if (!other.m_owns)
       return;
-    *reinterpret_cast<First*>(&m_storage)
-      = *other.get((First*)nullptr);
+    set(*other.get((First*)nullptr));
   }
 
   variant_base(variant_base &&other)
     : Base(std::move(other))
   {
     if (!other.m_owns)
       return;
-    *reinterpret_cast<First*>(&m_storage)
-      = std::move(*other.get((First*)nullptr));
+    set(std::move(*other.get((First*)nullptr)));
+  }
+
+  variant_base& operator=(const variant_base &other)
+  {
+    if (other.m_owns)
+      set(*other.get((First*)nullptr));
+    else
+      Base::operator=(static_cast<const Base&>(other));
+    return *this;
   }
 
   void set(const First &val)
@@ -264,6 +271,15 @@ class variant_base<Size, Align>
   {
     assert(false);
   }
+
+  void operator=(const variant_base&)
+  {}
+
+  template<typename T>
+  void operator=(const T&)
+  {
+    assert(false);
+  }
 };
 
 }  // detail
@@ -277,6 +293,14 @@ class variant
 {
   typedef detail::variant_base<0,0,Types...> Base;
 
+protected:
+
+  template <typename T>
+  const T* get_ptr() const
+  {
+    return Base::get((const T*)nullptr);
+  }
+
 public:
 
   variant() {}
@@ -299,6 +323,12 @@ class variant
     : Base(std::move(val))
   {}
 
+  variant& operator=(const variant &other)
+  {
+    Base::operator=(static_cast<const Base&>(other));
+    return *this;
+  }
+
   template <typename T>
   variant& operator=(T&& val)
   {
@@ -334,6 +364,60 @@ class variant
   {
     return *Base::get((const T*)nullptr);
   }
+
+  template <typename T>
+  const T* operator->() const
+  {
+    return get_ptr<T>();
+  }
+};
+
+
+/*
+  Object x of type opt<T> can be either empty or hold value of type T. In
+  the latter case reference to stored object can be obtained with x.get()
+  and stored object's methods can be called via operator->: x->method().
+*/
+
+template < typename Type >
+class opt
+  : private variant<Type>
+{
+  typedef variant<Type> Base;
+
+public:
+
+  opt()
+  {}
+
+  opt(const opt &other)
+    : Base(static_cast<const Base&>(other))
+  {}
+
+  template <typename... T>
+  opt(T... args)
+    : Base(Type(args...))
+  {}
+
+  opt& operator=(const opt &other)
+  {
+    Base::operator=(static_cast<const Base&>(other));
+    return *this;
+  }
+
+  opt& operator=(const Type& val)
+  {
+    Base::operator=(val);
+    return *this;
+  }
+
+  using Base::operator bool;
+  using Base::get;
+
+  const Type* operator->() const
+  {
+    return Base::template get_ptr<Type>();
+  }
 };