Variant: Remove requriment of VariantId (#9313)

kghost · pull[bot] · commit 13825001ad75 · 2021-09-23T14:03:30.000Z
diff --git a/src/app/util/af-types.h b/src/app/util/af-types.h
@@ -1297,50 +1297,42 @@ class MessageSendDestination
 private:
     struct VariantViaBinding
     {
-        static constexpr const std::size_t VariantId = 1;
         explicit VariantViaBinding(uint8_t bindingIndex) : mBindingIndex(bindingIndex) {}
         uint8_t mBindingIndex;
     };
 
     struct VariantViaAddressTable
     {
-        static constexpr const std::size_t VariantId = 2;
     };
 
     struct VariantDirect
     {
-        static constexpr const std::size_t VariantId = 3;
         explicit VariantDirect(NodeId nodeId) : mNodeId(nodeId) {}
         NodeId mNodeId;
     };
 
     struct VariantMulticast
     {
-        static constexpr const std::size_t VariantId = 4;
         explicit VariantMulticast(GroupId groupId) : mGroupId(groupId) {}
         GroupId mGroupId;
     };
 
     struct VariantMulticastWithAlias
     {
-        static constexpr const std::size_t VariantId = 5;
         explicit VariantMulticastWithAlias(GroupId groupId) : mGroupId(groupId) {}
         GroupId mGroupId;
     };
 
     struct VariantBroadcast
     {
-        static constexpr const std::size_t VariantId = 6;
     };
 
     struct VariantBroadcastWithAlias
     {
-        static constexpr const std::size_t VariantId = 7;
     };
 
     struct VariantViaExchange
     {
-        static constexpr const std::size_t VariantId = 8;
         explicit VariantViaExchange(Messaging::ExchangeContext * exchangeContext) : mExchangeContext(exchangeContext) {}
         Messaging::ExchangeContext * mExchangeContext;
     };
diff --git a/src/channel/ChannelContext.h b/src/channel/ChannelContext.h
@@ -136,7 +136,6 @@ class ChannelContext : public ReferenceCounted<ChannelContext, ChannelContextDel
     // mPreparing is pretty big, consider move it outside
     struct PrepareVars
     {
-        static constexpr const size_t VariantId = 1;
         PrepareState mState;
         Inet::IPAddressType mAddressType;
         Inet::IPAddress mAddress;
@@ -146,7 +145,6 @@ class ChannelContext : public ReferenceCounted<ChannelContext, ChannelContextDel
 
     struct ReadyVars
     {
-        static constexpr const size_t VariantId = 2;
         ReadyVars(SessionHandle session) : mSession(session) {}
         const SessionHandle mSession;
     };
diff --git a/src/lib/support/Variant.h b/src/lib/support/Variant.h
@@ -30,55 +30,55 @@ namespace chip {
 
 namespace VariantInternal {
 
-template <typename... Ts>
+template <std::size_t Index, typename... Ts>
 struct VariantCurry;
 
-template <typename T, typename... Ts>
-struct VariantCurry<T, Ts...>
+template <std::size_t Index, typename T, typename... Ts>
+struct VariantCurry<Index, T, Ts...>
 {
     inline static void Destroy(std::size_t id, void * data)
     {
-        if (id == T::VariantId)
+        if (id == Index)
             reinterpret_cast<T *>(data)->~T();
         else
-            VariantCurry<Ts...>::Destroy(id, data);
+            VariantCurry<Index + 1, Ts...>::Destroy(id, data);
     }
 
     inline static void Move(std::size_t that_t, void * that_v, void * this_v)
     {
-        if (that_t == T::VariantId)
+        if (that_t == Index)
             new (this_v) T(std::move(*reinterpret_cast<T *>(that_v)));
         else
-            VariantCurry<Ts...>::Move(that_t, that_v, this_v);
+            VariantCurry<Index + 1, Ts...>::Move(that_t, that_v, this_v);
     }
 
     inline static void Copy(std::size_t that_t, const void * that_v, void * this_v)
     {
-        if (that_t == T::VariantId)
+        if (that_t == Index)
         {
             new (this_v) T(*reinterpret_cast<const T *>(that_v));
         }
         else
         {
-            VariantCurry<Ts...>::Copy(that_t, that_v, this_v);
+            VariantCurry<Index + 1, Ts...>::Copy(that_t, that_v, this_v);
         }
     }
 
     inline static bool Equal(std::size_t type_t, const void * that_v, const void * this_v)
     {
-        if (type_t == T::VariantId)
+        if (type_t == Index)
         {
             return *reinterpret_cast<const T *>(this_v) == *reinterpret_cast<const T *>(that_v);
         }
         else
         {
-            return VariantCurry<Ts...>::Equal(type_t, that_v, this_v);
+            return VariantCurry<Index + 1, Ts...>::Equal(type_t, that_v, this_v);
         }
     }
 };
 
-template <>
-struct VariantCurry<>
+template <std::size_t Index>
+struct VariantCurry<Index>
 {
     inline static void Destroy(std::size_t id, void * data) {}
     inline static void Move(std::size_t that_t, void * that_v, void * this_v) {}
@@ -90,23 +90,41 @@ struct VariantCurry<>
     }
 };
 
+template <typename T, typename TupleType>
+class TupleIndexOfType
+{
+private:
+    template <std::size_t Index>
+    static constexpr
+        typename std::enable_if<std::is_same<T, typename std::tuple_element<Index, TupleType>::type>::value, std::size_t>::type
+        calculate()
+    {
+        return Index;
+    }
+
+    template <std::size_t Index>
+    static constexpr
+        typename std::enable_if<!std::is_same<T, typename std::tuple_element<Index, TupleType>::type>::value, std::size_t>::type
+        calculate()
+    {
+        return calculate<Index + 1>();
+    }
+
+public:
+    static constexpr std::size_t value = calculate<0>();
+};
+
 } // namespace VariantInternal
 
 /**
  * @brief
  *   Represents a type-safe union. An instance of Variant at any given time either holds a value of one of its
- *   alternative types, or no value. Each type must define a unique value of a static field named VariantId.
+ *   alternative types, or no value.
  *
  *   Example:
- *     struct Type1
- *     {
- *         static constexpr const std::size_t VariantId = 1;
- *     };
+ *     struct Type1 {};
  *
- *     struct Type2
- *     {
- *         static constexpr const std::size_t VariantId = 2;
- *     };
+ *     struct Type2 {};
  *
  *     Variant<Type1, Type2> v;
  *     v.Set<Type1>(); // v contains Type1
@@ -121,7 +139,7 @@ struct Variant
     static constexpr std::size_t kInvalidType = SIZE_MAX;
 
     using Data  = typename std::aligned_storage<kDataSize, kDataAlign>::type;
-    using Curry = VariantInternal::VariantCurry<Ts...>;
+    using Curry = VariantInternal::VariantCurry<0, Ts...>;
 
     std::size_t mTypeId;
     Data mData;
@@ -158,13 +176,13 @@ struct Variant
 
     bool operator==(const Variant & other) const
     {
-        return GetType() == other.GetType() && Curry::Equal(mTypeId, &other.mData, &mData);
+        return GetType() == other.GetType() && (!Valid() || Curry::Equal(mTypeId, &other.mData, &mData));
     }
 
     template <typename T>
     bool Is() const
     {
-        return (mTypeId == T::VariantId);
+        return (mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value);
     }
 
     std::size_t GetType() const { return mTypeId; }
@@ -176,20 +194,20 @@ struct Variant
     {
         Curry::Destroy(mTypeId, &mData);
         new (&mData) T(std::forward<Args>(args)...);
-        mTypeId = T::VariantId;
+        mTypeId = VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value;
     }
 
     template <typename T>
     T & Get()
     {
-        VerifyOrDie(mTypeId == T::VariantId);
+        VerifyOrDie((mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value));
         return *reinterpret_cast<T *>(&mData);
     }
 
     template <typename T>
     const T & Get() const
     {
-        VerifyOrDie(mTypeId == T::VariantId);
+        VerifyOrDie((mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value));
         return *reinterpret_cast<const T *>(&mData);
     }
 
diff --git a/src/lib/support/tests/TestVariant.cpp b/src/lib/support/tests/TestVariant.cpp
@@ -25,23 +25,20 @@ namespace {
 
 struct Simple
 {
-    static constexpr const std::size_t VariantId = 1;
+    bool operator==(const Simple &) const { return true; }
 };
 
 struct Pod
 {
-    static constexpr const std::size_t VariantId = 2;
-
     Pod(int v1, int v2) : m1(v1), m2(v2) {}
+    bool operator==(const Pod & other) const { return m1 == other.m1 && m2 == other.m2; }
 
     int m1;
     int m2;
 };
 
 struct Movable
 {
-    static constexpr const std::size_t VariantId = 3;
-
     Movable(int v1, int v2) : m1(v1), m2(v2) {}
 
     Movable(Movable &) = delete;
@@ -56,8 +53,6 @@ struct Movable
 
 struct Count
 {
-    static constexpr const std::size_t VariantId = 4;
-
     Count() { ++created; }
     ~Count() { ++destroyed; }
 
@@ -213,6 +208,50 @@ void TestVariantMoveAssign(nlTestSuite * inSuite, void * inContext)
     NL_TEST_ASSERT(inSuite, v2.Get<Pod>().m2 == 10);
 }
 
+void TestVariantCompare(nlTestSuite * inSuite, void * inContext)
+{
+    Variant<Simple, Pod> v0;
+    Variant<Simple, Pod> v1;
+    Variant<Simple, Pod> v2;
+    Variant<Simple, Pod> v3;
+    Variant<Simple, Pod> v4;
+
+    v1.Set<Simple>();
+    v2.Set<Pod>(5, 10);
+    v3.Set<Pod>(5, 10);
+    v4.Set<Pod>(5, 11);
+
+    NL_TEST_ASSERT(inSuite, (v0 == v0));
+    NL_TEST_ASSERT(inSuite, !(v0 == v1));
+    NL_TEST_ASSERT(inSuite, !(v0 == v2));
+    NL_TEST_ASSERT(inSuite, !(v0 == v3));
+    NL_TEST_ASSERT(inSuite, !(v0 == v4));
+
+    NL_TEST_ASSERT(inSuite, !(v1 == v0));
+    NL_TEST_ASSERT(inSuite, (v1 == v1));
+    NL_TEST_ASSERT(inSuite, !(v1 == v2));
+    NL_TEST_ASSERT(inSuite, !(v1 == v3));
+    NL_TEST_ASSERT(inSuite, !(v1 == v4));
+
+    NL_TEST_ASSERT(inSuite, !(v2 == v0));
+    NL_TEST_ASSERT(inSuite, !(v2 == v1));
+    NL_TEST_ASSERT(inSuite, (v2 == v2));
+    NL_TEST_ASSERT(inSuite, (v2 == v3));
+    NL_TEST_ASSERT(inSuite, !(v2 == v4));
+
+    NL_TEST_ASSERT(inSuite, !(v3 == v0));
+    NL_TEST_ASSERT(inSuite, !(v3 == v1));
+    NL_TEST_ASSERT(inSuite, (v3 == v2));
+    NL_TEST_ASSERT(inSuite, (v3 == v3));
+    NL_TEST_ASSERT(inSuite, !(v3 == v4));
+
+    NL_TEST_ASSERT(inSuite, !(v4 == v0));
+    NL_TEST_ASSERT(inSuite, !(v4 == v1));
+    NL_TEST_ASSERT(inSuite, !(v4 == v2));
+    NL_TEST_ASSERT(inSuite, !(v4 == v3));
+    NL_TEST_ASSERT(inSuite, (v4 == v4));
+}
+
 int Setup(void * inContext)
 {
     return SUCCESS;
@@ -229,10 +268,11 @@ int Teardown(void * inContext)
 /**
  *   Test Suite. It lists all the test functions.
  */
-static const nlTest sTests[] = { NL_TEST_DEF_FN(TestVariantSimple),     NL_TEST_DEF_FN(TestVariantMovable),
-                                 NL_TEST_DEF_FN(TestVariantCtorDtor),   NL_TEST_DEF_FN(TestVariantCopy),
-                                 NL_TEST_DEF_FN(TestVariantMove),       NL_TEST_DEF_FN(TestVariantCopyAssign),
-                                 NL_TEST_DEF_FN(TestVariantMoveAssign), NL_TEST_SENTINEL() };
+static const nlTest sTests[] = {
+    NL_TEST_DEF_FN(TestVariantSimple),     NL_TEST_DEF_FN(TestVariantMovable), NL_TEST_DEF_FN(TestVariantCtorDtor),
+    NL_TEST_DEF_FN(TestVariantCopy),       NL_TEST_DEF_FN(TestVariantMove),    NL_TEST_DEF_FN(TestVariantCopyAssign),
+    NL_TEST_DEF_FN(TestVariantMoveAssign), NL_TEST_DEF_FN(TestVariantCompare), NL_TEST_SENTINEL()
+};
 
 int TestVariant()
 {

Original file line number	Diff line number	Diff line change
`@@ -1297,50 +1297,42 @@ class MessageSendDestination`
`1297`	`1297`	`private:`
`1298`	`1298`	`struct VariantViaBinding`
`1299`	`1299`	`{`
`1300`		`- static constexpr const std::size_t VariantId = 1;`
`1301`	`1300`	`explicit VariantViaBinding(uint8_t bindingIndex) : mBindingIndex(bindingIndex) {}`
`1302`	`1301`	`uint8_t mBindingIndex;`
`1303`	`1302`	`};`
`1304`	`1303`
`1305`	`1304`	`struct VariantViaAddressTable`
`1306`	`1305`	`{`
`1307`		`- static constexpr const std::size_t VariantId = 2;`
`1308`	`1306`	`};`
`1309`	`1307`
`1310`	`1308`	`struct VariantDirect`
`1311`	`1309`	`{`
`1312`		`- static constexpr const std::size_t VariantId = 3;`
`1313`	`1310`	`explicit VariantDirect(NodeId nodeId) : mNodeId(nodeId) {}`
`1314`	`1311`	`NodeId mNodeId;`
`1315`	`1312`	`};`
`1316`	`1313`
`1317`	`1314`	`struct VariantMulticast`
`1318`	`1315`	`{`
`1319`		`- static constexpr const std::size_t VariantId = 4;`
`1320`	`1316`	`explicit VariantMulticast(GroupId groupId) : mGroupId(groupId) {}`
`1321`	`1317`	`GroupId mGroupId;`
`1322`	`1318`	`};`
`1323`	`1319`
`1324`	`1320`	`struct VariantMulticastWithAlias`
`1325`	`1321`	`{`
`1326`		`- static constexpr const std::size_t VariantId = 5;`
`1327`	`1322`	`explicit VariantMulticastWithAlias(GroupId groupId) : mGroupId(groupId) {}`
`1328`	`1323`	`GroupId mGroupId;`
`1329`	`1324`	`};`
`1330`	`1325`
`1331`	`1326`	`struct VariantBroadcast`
`1332`	`1327`	`{`
`1333`		`- static constexpr const std::size_t VariantId = 6;`
`1334`	`1328`	`};`
`1335`	`1329`
`1336`	`1330`	`struct VariantBroadcastWithAlias`
`1337`	`1331`	`{`
`1338`		`- static constexpr const std::size_t VariantId = 7;`
`1339`	`1332`	`};`
`1340`	`1333`
`1341`	`1334`	`struct VariantViaExchange`
`1342`	`1335`	`{`
`1343`		`- static constexpr const std::size_t VariantId = 8;`
`1344`	`1336`	`explicit VariantViaExchange(Messaging::ExchangeContext * exchangeContext) : mExchangeContext(exchangeContext) {}`
`1345`	`1337`	`Messaging::ExchangeContext * mExchangeContext;`
`1346`	`1338`	`};`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,6 @@ class ChannelContext : public ReferenceCounted<ChannelContext, ChannelContextDel`
`136`	`136`	`// mPreparing is pretty big, consider move it outside`
`137`	`137`	`struct PrepareVars`
`138`	`138`	`{`
`139`		`- static constexpr const size_t VariantId = 1;`
`140`	`139`	`PrepareState mState;`
`141`	`140`	`Inet::IPAddressType mAddressType;`
`142`	`141`	`Inet::IPAddress mAddress;`
`@@ -146,7 +145,6 @@ class ChannelContext : public ReferenceCounted<ChannelContext, ChannelContextDel`
`146`	`145`
`147`	`146`	`struct ReadyVars`
`148`	`147`	`{`
`149`		`- static constexpr const size_t VariantId = 2;`
`150`	`148`	`ReadyVars(SessionHandle session) : mSession(session) {}`
`151`	`149`	`const SessionHandle mSession;`
`152`	`150`	`};`
Original file line number	Diff line number	Diff line change
`@@ -30,55 +30,55 @@ namespace chip {`
`30`	`30`
`31`	`31`	`namespace VariantInternal {`
`32`	`32`
`33`		`-template <typename... Ts>`
	`33`	`+template <std::size_t Index, typename... Ts>`
`34`	`34`	`struct VariantCurry;`
`35`	`35`
`36`		`-template <typename T, typename... Ts>`
`37`		`-struct VariantCurry<T, Ts...>`
	`36`	`+template <std::size_t Index, typename T, typename... Ts>`
	`37`	`+struct VariantCurry<Index, T, Ts...>`
`38`	`38`	`{`
`39`	`39`	`inline static void Destroy(std::size_t id, void * data)`
`40`	`40`	`{`
`41`		`- if (id == T::VariantId)`
	`41`	`+ if (id == Index)`
`42`	`42`	`reinterpret_cast<T *>(data)->~T();`
`43`	`43`	`else`
`44`		`- VariantCurry<Ts...>::Destroy(id, data);`
	`44`	`+ VariantCurry<Index + 1, Ts...>::Destroy(id, data);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`inline static void Move(std::size_t that_t, void * that_v, void * this_v)`
`48`	`48`	`{`
`49`		`- if (that_t == T::VariantId)`
	`49`	`+ if (that_t == Index)`
`50`	`50`	`new (this_v) T(std::move(reinterpret_cast<T >(that_v)));`
`51`	`51`	`else`
`52`		`- VariantCurry<Ts...>::Move(that_t, that_v, this_v);`
	`52`	`+ VariantCurry<Index + 1, Ts...>::Move(that_t, that_v, this_v);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`inline static void Copy(std::size_t that_t, const void * that_v, void * this_v)`
`56`	`56`	`{`
`57`		`- if (that_t == T::VariantId)`
	`57`	`+ if (that_t == Index)`
`58`	`58`	`{`
`59`	`59`	`new (this_v) T(reinterpret_cast<const T >(that_v));`
`60`	`60`	`}`
`61`	`61`	`else`
`62`	`62`	`{`
`63`		`- VariantCurry<Ts...>::Copy(that_t, that_v, this_v);`
	`63`	`+ VariantCurry<Index + 1, Ts...>::Copy(that_t, that_v, this_v);`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`inline static bool Equal(std::size_t type_t, const void * that_v, const void * this_v)`
`68`	`68`	`{`
`69`		`- if (type_t == T::VariantId)`
	`69`	`+ if (type_t == Index)`
`70`	`70`	`{`
`71`	`71`	`return reinterpret_cast<const T >(this_v) == reinterpret_cast<const T >(that_v);`
`72`	`72`	`}`
`73`	`73`	`else`
`74`	`74`	`{`
`75`		`- return VariantCurry<Ts...>::Equal(type_t, that_v, this_v);`
	`75`	`+ return VariantCurry<Index + 1, Ts...>::Equal(type_t, that_v, this_v);`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`	`};`
`79`	`79`
`80`		`-template <>`
`81`		`-struct VariantCurry<>`
	`80`	`+template <std::size_t Index>`
	`81`	`+struct VariantCurry<Index>`
`82`	`82`	`{`
`83`	`83`	`inline static void Destroy(std::size_t id, void * data) {}`
`84`	`84`	`inline static void Move(std::size_t that_t, void * that_v, void * this_v) {}`
`@@ -90,23 +90,41 @@ struct VariantCurry<>`
`90`	`90`	`}`
`91`	`91`	`};`
`92`	`92`
	`93`	`+template <typename T, typename TupleType>`
	`94`	`+class TupleIndexOfType`
	`95`	`+{`
	`96`	`+private:`
	`97`	`+ template <std::size_t Index>`
	`98`	`+ static constexpr`
	`99`	`+ typename std::enable_if<std::is_same<T, typename std::tuple_element<Index, TupleType>::type>::value, std::size_t>::type`
	`100`	`+ calculate()`
	`101`	`+ {`
	`102`	`+ return Index;`
	`103`	`+ }`
	`104`	`+`
	`105`	`+ template <std::size_t Index>`
	`106`	`+ static constexpr`
	`107`	`+ typename std::enable_if<!std::is_same<T, typename std::tuple_element<Index, TupleType>::type>::value, std::size_t>::type`
	`108`	`+ calculate()`
	`109`	`+ {`
	`110`	`+ return calculate<Index + 1>();`
	`111`	`+ }`
	`112`	`+`
	`113`	`+public:`
	`114`	`+ static constexpr std::size_t value = calculate<0>();`
	`115`	`+};`
	`116`	`+`
`93`	`117`	`} // namespace VariantInternal`
`94`	`118`
`95`	`119`	`/**`
`96`	`120`	`* @brief`
`97`	`121`	`* Represents a type-safe union. An instance of Variant at any given time either holds a value of one of its`
`98`		`- * alternative types, or no value. Each type must define a unique value of a static field named VariantId.`
	`122`	`+ * alternative types, or no value.`
`99`	`123`	`*`
`100`	`124`	`* Example:`
`101`		`- * struct Type1`
`102`		`- * {`
`103`		`- * static constexpr const std::size_t VariantId = 1;`
`104`		`- * };`
	`125`	`+ * struct Type1 {};`
`105`	`126`	`*`
`106`		`- * struct Type2`
`107`		`- * {`
`108`		`- * static constexpr const std::size_t VariantId = 2;`
`109`		`- * };`
	`127`	`+ * struct Type2 {};`
`110`	`128`	`*`
`111`	`129`	`* Variant<Type1, Type2> v;`
`112`	`130`	`* v.Set<Type1>(); // v contains Type1`
`@@ -121,7 +139,7 @@ struct Variant`
`121`	`139`	`static constexpr std::size_t kInvalidType = SIZE_MAX;`
`122`	`140`
`123`	`141`	`using Data = typename std::aligned_storage<kDataSize, kDataAlign>::type;`
`124`		`- using Curry = VariantInternal::VariantCurry<Ts...>;`
	`142`	`+ using Curry = VariantInternal::VariantCurry<0, Ts...>;`
`125`	`143`
`126`	`144`	`std::size_t mTypeId;`
`127`	`145`	`Data mData;`
`@@ -158,13 +176,13 @@ struct Variant`
`158`	`176`
`159`	`177`	`bool operator==(const Variant & other) const`
`160`	`178`	`{`
`161`		`- return GetType() == other.GetType() && Curry::Equal(mTypeId, &other.mData, &mData);`
	`179`	`+ return GetType() == other.GetType() && (!Valid() \|\| Curry::Equal(mTypeId, &other.mData, &mData));`
`162`	`180`	`}`
`163`	`181`
`164`	`182`	`template <typename T>`
`165`	`183`	`bool Is() const`
`166`	`184`	`{`
`167`		`- return (mTypeId == T::VariantId);`
	`185`	`+ return (mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value);`
`168`	`186`	`}`
`169`	`187`
`170`	`188`	`std::size_t GetType() const { return mTypeId; }`
`@@ -176,20 +194,20 @@ struct Variant`
`176`	`194`	`{`
`177`	`195`	`Curry::Destroy(mTypeId, &mData);`
`178`	`196`	`new (&mData) T(std::forward<Args>(args)...);`
`179`		`- mTypeId = T::VariantId;`
	`197`	`+ mTypeId = VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value;`
`180`	`198`	`}`
`181`	`199`
`182`	`200`	`template <typename T>`
`183`	`201`	`T & Get()`
`184`	`202`	`{`
`185`		`- VerifyOrDie(mTypeId == T::VariantId);`
	`203`	`+ VerifyOrDie((mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value));`
`186`	`204`	`return reinterpret_cast<T >(&mData);`
`187`	`205`	`}`
`188`	`206`
`189`	`207`	`template <typename T>`
`190`	`208`	`const T & Get() const`
`191`	`209`	`{`
`192`		`- VerifyOrDie(mTypeId == T::VariantId);`
	`210`	`+ VerifyOrDie((mTypeId == VariantInternal::TupleIndexOfType<T, std::tuple<Ts...>>::value));`
`193`	`211`	`return reinterpret_cast<const T >(&mData);`
`194`	`212`	`}`
`195`	`213`