source/core/variant.h

   1 #ifndef MSP_CORE_VARIANT_H_
   2 #define MSP_CORE_VARIANT_H_
   3
   4 #include <stdexcept>
   5 #include <type_traits>
   6 #include <typeinfo>
   7 #include "meta.h"
   8
   9 namespace Msp {
  10
  11 class type_mismatch: public std::runtime_error
  12 {
  13 public:
  14         type_mismatch(const std::type_info &, const std::type_info &);
  15         ~type_mismatch() throw() override = default;
  16 };
  17
  18
  19 class Variant
  20 {
  21 private:
  22         struct StoreBase
  23         {
  24                 virtual ~StoreBase() { }
  25
  26                 virtual const std::type_info &type_id() const = 0;
  27                 virtual StoreBase *clone() const = 0;
  28                 virtual bool type_equals(const StoreBase &) const = 0;
  29                 virtual bool value_equals(const StoreBase &) const = 0;
  30         };
  31
  32         template<typename T>
  33         struct Store: public StoreBase
  34         {
  35                 T data;
  36
  37                 Store(const T &d): data(d) { }
  38
  39                 const std::type_info &type_id() const override { return typeid(T); }
  40                 StoreBase *clone() const override { return new Store<T>(data); }
  41                 bool type_equals(const StoreBase &s) const override { return dynamic_cast<const Store<T> *>(&s); }
  42                 bool value_equals(const StoreBase &s) const override { return _value_equals<T>(s); }
  43
  44                 template<typename U>
  45                 typename std::enable_if<IsEqualityComparable<U>::value, bool>::type _value_equals(const StoreBase &s) const
  46                 { const Store<T> *t = dynamic_cast<const Store<T> *>(&s); return (t && t->data==data); }
  47
  48                 template<typename U>
  49                 typename std::enable_if<!IsEqualityComparable<U>::value, bool>::type _value_equals(const StoreBase &) const
  50                 { return false; }
  51         };
  52
  53         StoreBase *store = nullptr;
  54
  55 public:
  56         Variant() = default;
  57         template<typename T>
  58         Variant(const T &v): store(new Store<typename std::remove_cv<T>::type>(v)) { }
  59         Variant(const Variant &v): store(v.store ? v.store->clone() : nullptr) { }
  60         ~Variant() { delete store; }
  61
  62         template<typename T>
  63         Variant &operator=(const T &v)
  64         {
  65                 delete store;
  66                 store = new Store<typename std::remove_cv<T>::type>(v);
  67                 return *this;
  68         }
  69
  70         Variant &operator=(const Variant &v)
  71         {
  72                 if(&v==this)
  73                         return *this;
  74
  75                 delete store;
  76                 store = (v.store ? v.store->clone() : nullptr);
  77                 return *this;
  78         }
  79
  80 private:
  81         template<typename T>
  82         Store<typename std::remove_cv<T>::type> *get_typed_store() const
  83         {
  84                 typedef typename std::remove_cv<T>::type NCT;
  85                 Store<NCT> *s = dynamic_cast<Store<NCT> *>(store);
  86                 if(!s)
  87                         throw type_mismatch(typeid(T), (store ? store->type_id() : typeid(void)));
  88                 return s;
  89         }
  90
  91 public:
  92         template<typename T>
  93         T &value()
  94         {
  95                 return get_typed_store<T>()->data;
  96         }
  97
  98         template<typename T>
  99         const T &value() const
 100         {
 101                 return get_typed_store<T>()->data;
 102         }
 103
 104         template<typename T>
 105         bool check_type() const
 106         {
 107                 return dynamic_cast<Store<typename std::remove_cv<T>::type> *>(store);
 108         }
 109
 110         bool check_same_type(const Variant &v) const
 111         { return store && v.store && store->type_equals(*v.store); }
 112
 113         bool operator==(const Variant &v) const
 114         { return store && v.store && store->value_equals(*v.store); }
 115
 116         bool operator!=(const Variant &v) const
 117         { return !(operator==(v)); }
 118
 119         template<typename T>
 120         operator T() const
 121         { return value<T>(); }
 122 };
 123
 124 } // namespace Msp
 125
 126 #endif