src/test/DBusVariantTest.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 #include <iostream>
   5 #include <string>
   6 #include <tuple>
   7 #include <type_traits>
   8
   9 template <typename _SearchType, typename _CurrentType, typename... _RestTypes>
  10 struct VariantTypeSelector: VariantTypeSelector<_SearchType, _RestTypes...> {
  11 };
  12
  13 template <typename _SearchType, typename... _RestTypes>
  14 struct VariantTypeSelector<_SearchType, _SearchType, _RestTypes...> {
  15     typedef _SearchType type;
  16 };
  17
  18 template <typename... _Types>
  19 class Variant {
  20  private:
  21     typedef std::tuple_size<std::tuple<_Types...>> TypesTupleSize;
  22
  23  public:
  24     Variant(): valueType_(TypesTupleSize::value) {
  25     }
  26
  27     Variant(const Variant& fromVariant):
  28         valueType_(fromVariant.valueType_),
  29         valueStorage_(fromVariant.valueStorage_) {
  30     }
  31
  32     Variant(Variant&& fromVariant):
  33         valueType_(std::move(fromVariant.valueType_)),
  34         valueStorage_(std::move(fromVariant.valueStorage_)) {
  35         fromVariant.valueType_ = TypesTupleSize::value;
  36     }
  37
  38     ~Variant() {
  39         if (hasValue()) {
  40             // TODO call value destructor
  41         }
  42     }
  43
  44     Variant& operator=(const Variant& fromVariant) {
  45         // TODO
  46         return *this;
  47     }
  48
  49     Variant& operator=(Variant&& fromVariant) {
  50         // TODO
  51         return *this;
  52     }
  53
  54     // TODO use std::enable_if
  55     template <typename _Type>
  56     Variant(const _Type& value) {
  57         // TODO index by type
  58         valueType_ = 0;
  59         new (&valueStorage_) _Type(value);
  60     }
  61
  62     // TODO use std::enable_if
  63     template <typename _Type>
  64     Variant(_Type && value) {
  65         // TODO index by type
  66         valueType_ = 0;
  67         new (&valueStorage_) typename std::remove_reference<_Type>::type(std::move(value));
  68     }
  69
  70     template <typename _Type>
  71     const typename VariantTypeSelector<_Type, _Types...>::type & get(bool& success) const {
  72         // TODO assert _Type in _Types
  73         success = true;
  74         return *(reinterpret_cast<const _Type *>(&valueStorage_));
  75     }
  76
  77  private:
  78     inline bool hasValue() const {
  79         return valueType_ < TypesTupleSize::value;
  80     }
  81
  82     size_t valueType_;
  83     // TODO calculate maximum storage
  84     std::aligned_storage<80>::type valueStorage_;
  85 };
  86
  87
  88
  89 int main(int argc, char** argv) {
  90     int fromInt = 5;
  91     Variant<int, double, double, std::string> myVariant(fromInt);
  92     bool success;
  93     const int& myInt = myVariant.get<int>(success);
  94 //    const float& myFloat = myVariant.get<float>(success);
  95
  96     std::cout << "myInt = " << myInt << " (" << std::boolalpha << success << ")\n";
  97     return 0;
  98 }