diff options
Diffstat (limited to 'mfbt/Variant.h')
| -rw-r--r-- | mfbt/Variant.h | 928 |
1 files changed, 928 insertions, 0 deletions
diff --git a/mfbt/Variant.h b/mfbt/Variant.h new file mode 100644 index 0000000000..d1db3a2cc9 --- /dev/null +++ b/mfbt/Variant.h @@ -0,0 +1,928 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* A template class for tagged unions. */ + +#include <new> +#include <stdint.h> + +#include "mozilla/Assertions.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/OperatorNewExtensions.h" +#include "mozilla/TemplateLib.h" +#include <type_traits> +#include <utility> + +#ifndef mozilla_Variant_h +# define mozilla_Variant_h + +namespace IPC { +template <typename T> +struct ParamTraits; +} // namespace IPC + +namespace mozilla { + +namespace ipc { +template <typename T> +struct IPDLParamTraits; +} // namespace ipc + +template <typename... Ts> +class Variant; + +namespace detail { + +// Nth<N, types...>::Type is the Nth type (0-based) in the list of types Ts. +template <size_t N, typename... Ts> +struct Nth; + +template <typename T, typename... Ts> +struct Nth<0, T, Ts...> { + using Type = T; +}; + +template <size_t N, typename T, typename... Ts> +struct Nth<N, T, Ts...> { + using Type = typename Nth<N - 1, Ts...>::Type; +}; + +/// SelectVariantTypeHelper is used in the implementation of SelectVariantType. +template <typename T, typename... Variants> +struct SelectVariantTypeHelper; + +template <typename T> +struct SelectVariantTypeHelper<T> { + static constexpr size_t count = 0; +}; + +template <typename T, typename... Variants> +struct SelectVariantTypeHelper<T, T, Variants...> { + typedef T Type; + static constexpr size_t count = + 1 + SelectVariantTypeHelper<T, Variants...>::count; +}; + +template <typename T, typename... Variants> +struct SelectVariantTypeHelper<T, const T, Variants...> { + typedef const T Type; + static constexpr size_t count = + 1 + SelectVariantTypeHelper<T, Variants...>::count; +}; + +template <typename T, typename... Variants> +struct SelectVariantTypeHelper<T, const T&, Variants...> { + typedef const T& Type; + static constexpr size_t count = + 1 + SelectVariantTypeHelper<T, Variants...>::count; +}; + +template <typename T, typename... Variants> +struct SelectVariantTypeHelper<T, T&&, Variants...> { + typedef T&& Type; + static constexpr size_t count = + 1 + SelectVariantTypeHelper<T, Variants...>::count; +}; + +template <typename T, typename Head, typename... Variants> +struct SelectVariantTypeHelper<T, Head, Variants...> + : public SelectVariantTypeHelper<T, Variants...> {}; + +/** + * SelectVariantType takes a type T and a list of variant types Variants and + * yields a type Type, selected from Variants, that can store a value of type T + * or a reference to type T. If no such type was found, Type is not defined. + * SelectVariantType also has a `count` member that contains the total number of + * selectable types (which will be used to check that a requested type is not + * ambiguously present twice.) + */ +template <typename T, typename... Variants> +struct SelectVariantType + : public SelectVariantTypeHelper< + std::remove_const_t<std::remove_reference_t<T>>, Variants...> {}; + +// Compute a fast, compact type that can be used to hold integral values that +// distinctly map to every type in Ts. +template <typename... Ts> +struct VariantTag { + private: + static const size_t TypeCount = sizeof...(Ts); + + public: + using Type = std::conditional_t< + (TypeCount <= 2), bool, + std::conditional_t<(TypeCount <= size_t(UINT_FAST8_MAX)), uint_fast8_t, + size_t // stop caring past a certain + // point :-) + >>; +}; + +// TagHelper gets the given sentinel tag value for the given type T. This has to +// be split out from VariantImplementation because you can't nest a partial +// template specialization within a template class. + +template <typename Tag, size_t N, typename T, typename U, typename Next, + bool isMatch> +struct TagHelper; + +// In the case where T != U, we continue recursion. +template <typename Tag, size_t N, typename T, typename U, typename Next> +struct TagHelper<Tag, N, T, U, Next, false> { + static Tag tag() { return Next::template tag<U>(); } +}; + +// In the case where T == U, return the tag number. +template <typename Tag, size_t N, typename T, typename U, typename Next> +struct TagHelper<Tag, N, T, U, Next, true> { + static Tag tag() { return Tag(N); } +}; + +// The VariantImplementation template provides the guts of mozilla::Variant. We +// create a VariantImplementation for each T in Ts... which handles +// construction, destruction, etc for when the Variant's type is T. If the +// Variant's type isn't T, it punts the request on to the next +// VariantImplementation. + +template <typename Tag, size_t N, typename... Ts> +struct VariantImplementation; + +// The singly typed Variant / recursion base case. +template <typename Tag, size_t N, typename T> +struct VariantImplementation<Tag, N, T> { + template <typename U> + static Tag tag() { + static_assert(std::is_same_v<T, U>, "mozilla::Variant: tag: bad type!"); + return Tag(N); + } + + template <typename Variant> + static void copyConstruct(void* aLhs, const Variant& aRhs) { + ::new (KnownNotNull, aLhs) T(aRhs.template as<N>()); + } + + template <typename Variant> + static void moveConstruct(void* aLhs, Variant&& aRhs) { + ::new (KnownNotNull, aLhs) T(aRhs.template extract<N>()); + } + + template <typename Variant> + static void destroy(Variant& aV) { + aV.template as<N>().~T(); + } + + template <typename Variant> + static bool equal(const Variant& aLhs, const Variant& aRhs) { + return aLhs.template as<N>() == aRhs.template as<N>(); + } + + template <typename Matcher, typename ConcreteVariant> + static decltype(auto) match(Matcher&& aMatcher, ConcreteVariant&& aV) { + if constexpr (std::is_invocable_v<Matcher, Tag, + decltype(std::forward<ConcreteVariant>(aV) + .template as<N>())>) { + return std::forward<Matcher>(aMatcher)( + Tag(N), std::forward<ConcreteVariant>(aV).template as<N>()); + } else { + return std::forward<Matcher>(aMatcher)( + std::forward<ConcreteVariant>(aV).template as<N>()); + } + } + + template <typename ConcreteVariant, typename Matcher> + static decltype(auto) matchN(ConcreteVariant&& aV, Matcher&& aMatcher) { + if constexpr (std::is_invocable_v<Matcher, Tag, + decltype(std::forward<ConcreteVariant>(aV) + .template as<N>())>) { + return std::forward<Matcher>(aMatcher)( + Tag(N), std::forward<ConcreteVariant>(aV).template as<N>()); + } else { + return std::forward<Matcher>(aMatcher)( + std::forward<ConcreteVariant>(aV).template as<N>()); + } + } +}; + +// VariantImplementation for some variant type T. +template <typename Tag, size_t N, typename T, typename... Ts> +struct VariantImplementation<Tag, N, T, Ts...> { + // The next recursive VariantImplementation. + using Next = VariantImplementation<Tag, N + 1, Ts...>; + + template <typename U> + static Tag tag() { + return TagHelper<Tag, N, T, U, Next, std::is_same_v<T, U>>::tag(); + } + + template <typename Variant> + static void copyConstruct(void* aLhs, const Variant& aRhs) { + if (aRhs.template is<N>()) { + ::new (KnownNotNull, aLhs) T(aRhs.template as<N>()); + } else { + Next::copyConstruct(aLhs, aRhs); + } + } + + template <typename Variant> + static void moveConstruct(void* aLhs, Variant&& aRhs) { + if (aRhs.template is<N>()) { + ::new (KnownNotNull, aLhs) T(aRhs.template extract<N>()); + } else { + Next::moveConstruct(aLhs, std::move(aRhs)); + } + } + + template <typename Variant> + static void destroy(Variant& aV) { + if (aV.template is<N>()) { + aV.template as<N>().~T(); + } else { + Next::destroy(aV); + } + } + + template <typename Variant> + static bool equal(const Variant& aLhs, const Variant& aRhs) { + if (aLhs.template is<N>()) { + MOZ_ASSERT(aRhs.template is<N>()); + return aLhs.template as<N>() == aRhs.template as<N>(); + } else { + return Next::equal(aLhs, aRhs); + } + } + + template <typename Matcher, typename ConcreteVariant> + static decltype(auto) match(Matcher&& aMatcher, ConcreteVariant&& aV) { + if (aV.template is<N>()) { + if constexpr (std::is_invocable_v<Matcher, Tag, + decltype(std::forward<ConcreteVariant>( + aV) + .template as<N>())>) { + return std::forward<Matcher>(aMatcher)( + Tag(N), std::forward<ConcreteVariant>(aV).template as<N>()); + } else { + return std::forward<Matcher>(aMatcher)( + std::forward<ConcreteVariant>(aV).template as<N>()); + } + } else { + // If you're seeing compilation errors here like "no matching + // function for call to 'match'" then that means that the + // Matcher doesn't exhaust all variant types. There must exist a + // Matcher::operator()(T&) for every variant type T. + // + // If you're seeing compilation errors here like "cannot initialize + // return object of type <...> with an rvalue of type <...>" then that + // means that the Matcher::operator()(T&) overloads are returning + // different types. They must all return the same type. + return Next::match(std::forward<Matcher>(aMatcher), + std::forward<ConcreteVariant>(aV)); + } + } + + template <typename ConcreteVariant, typename Mi, typename... Ms> + static decltype(auto) matchN(ConcreteVariant&& aV, Mi&& aMi, Ms&&... aMs) { + if (aV.template is<N>()) { + if constexpr (std::is_invocable_v<Mi, Tag, + decltype(std::forward<ConcreteVariant>( + aV) + .template as<N>())>) { + static_assert( + std::is_same_v< + decltype(std::forward<Mi>(aMi)( + Tag(N), + std::forward<ConcreteVariant>(aV).template as<N>())), + decltype(Next::matchN(std::forward<ConcreteVariant>(aV), + std::forward<Ms>(aMs)...))>, + "all matchers must have the same return type"); + return std::forward<Mi>(aMi)( + Tag(N), std::forward<ConcreteVariant>(aV).template as<N>()); + } else { + static_assert( + std::is_same_v< + decltype(std::forward<Mi>(aMi)( + std::forward<ConcreteVariant>(aV).template as<N>())), + decltype(Next::matchN(std::forward<ConcreteVariant>(aV), + std::forward<Ms>(aMs)...))>, + "all matchers must have the same return type"); + return std::forward<Mi>(aMi)( + std::forward<ConcreteVariant>(aV).template as<N>()); + } + } else { + // If you're seeing compilation errors here like "no matching + // function for call to 'match'" then that means that the + // Matchers don't exhaust all variant types. There must exist a + // Matcher (with its operator()(T&)) for every variant type T, in the + // exact same order. + return Next::matchN(std::forward<ConcreteVariant>(aV), + std::forward<Ms>(aMs)...); + } + } +}; + +/** + * AsVariantTemporary stores a value of type T to allow construction of a + * Variant value via type inference. Because T is copied and there's no + * guarantee that the copy can be elided, AsVariantTemporary is best used with + * primitive or very small types. + */ +template <typename T> +struct AsVariantTemporary { + explicit AsVariantTemporary(const T& aValue) : mValue(aValue) {} + + template <typename U> + explicit AsVariantTemporary(U&& aValue) : mValue(std::forward<U>(aValue)) {} + + AsVariantTemporary(const AsVariantTemporary& aOther) + : mValue(aOther.mValue) {} + + AsVariantTemporary(AsVariantTemporary&& aOther) + : mValue(std::move(aOther.mValue)) {} + + AsVariantTemporary() = delete; + void operator=(const AsVariantTemporary&) = delete; + void operator=(AsVariantTemporary&&) = delete; + + std::remove_const_t<std::remove_reference_t<T>> mValue; +}; + +} // namespace detail + +// Used to unambiguously specify one of the Variant's type. +template <typename T> +struct VariantType { + using Type = T; +}; + +// Used to specify one of the Variant's type by index. +template <size_t N> +struct VariantIndex { + static constexpr size_t index = N; +}; + +/** + * # mozilla::Variant + * + * A variant / tagged union / heterogenous disjoint union / sum-type template + * class. Similar in concept to (but not derived from) `boost::variant`. + * + * Sometimes, you may wish to use a C union with non-POD types. However, this is + * forbidden in C++ because it is not clear which type in the union should have + * its constructor and destructor run on creation and deletion + * respectively. This is the problem that `mozilla::Variant` solves. + * + * ## Usage + * + * A `mozilla::Variant` instance is constructed (via move or copy) from one of + * its variant types (ignoring const and references). It does *not* support + * construction from subclasses of variant types or types that coerce to one of + * the variant types. + * + * Variant<char, uint32_t> v1('a'); + * Variant<UniquePtr<A>, B, C> v2(MakeUnique<A>()); + * Variant<bool, char> v3(VariantType<char>, 0); // disambiguation needed + * Variant<int, int> v4(VariantIndex<1>, 0); // 2nd int + * + * Because specifying the full type of a Variant value is often verbose, + * there are two easier ways to construct values: + * + * A. AsVariant() can be used to construct a Variant value using type inference + * in contexts such as expressions or when returning values from functions. + * Because AsVariant() must copy or move the value into a temporary and this + * cannot necessarily be elided by the compiler, it's mostly appropriate only + * for use with primitive or very small types. + * + * Variant<char, uint32_t> Foo() { return AsVariant('x'); } + * // ... + * Variant<char, uint32_t> v1 = Foo(); // v1 holds char('x'). + * + * B. Brace-construction with VariantType or VariantIndex; this also allows + * in-place construction with any number of arguments. + * + * struct AB { AB(int, int){...} }; + * static Variant<AB, bool> foo() + * { + * return {VariantIndex<0>{}, 1, 2}; + * } + * // ... + * Variant<AB, bool> v0 = Foo(); // v0 holds AB(1,2). + * + * All access to the contained value goes through type-safe accessors. + * Either the stored type, or the type index may be provided. + * + * void + * Foo(Variant<A, B, C> v) + * { + * if (v.is<A>()) { + * A& ref = v.as<A>(); + * ... + * } else (v.is<1>()) { // Instead of v.is<B>. + * ... + * } else { + * ... + * } + * } + * + * In some situation, a Variant may be constructed from templated types, in + * which case it is possible that the same type could be given multiple times by + * an external developer. Or seemingly-different types could be aliases. + * In this case, repeated types can only be accessed through their index, to + * prevent ambiguous access by type. + * + * // Bad! + * template <typename T> + * struct ResultOrError + * { + * Variant<T, int> m; + * ResultOrError() : m(int(0)) {} // Error '0' by default + * ResultOrError(const T& r) : m(r) {} + * bool IsResult() const { return m.is<T>(); } + * bool IsError() const { return m.is<int>(); } + * }; + * // Now instantiante with the result being an int too: + * ResultOrError<int> myResult(123); // Fail! + * // In Variant<int, int>, which 'int' are we refering to, from inside + * // ResultOrError functions? + * + * // Good! + * template <typename T> + * struct ResultOrError + * { + * Variant<T, int> m; + * ResultOrError() : m(VariantIndex<1>{}, 0) {} // Error '0' by default + * ResultOrError(const T& r) : m(VariantIndex<0>{}, r) {} + * bool IsResult() const { return m.is<0>(); } // 0 -> T + * bool IsError() const { return m.is<1>(); } // 1 -> int + * }; + * // Now instantiante with the result being an int too: + * ResultOrError<int> myResult(123); // It now works! + * + * Attempting to use the contained value as type `T1` when the `Variant` + * instance contains a value of type `T2` causes an assertion failure. + * + * A a; + * Variant<A, B, C> v(a); + * v.as<B>(); // <--- Assertion failure! + * + * Trying to use a `Variant<Ts...>` instance as some type `U` that is not a + * member of the set of `Ts...` is a compiler error. + * + * A a; + * Variant<A, B, C> v(a); + * v.as<SomeRandomType>(); // <--- Compiler error! + * + * Additionally, you can turn a `Variant` that `is<T>` into a `T` by moving it + * out of the containing `Variant` instance with the `extract<T>` method: + * + * Variant<UniquePtr<A>, B, C> v(MakeUnique<A>()); + * auto ptr = v.extract<UniquePtr<A>>(); + * + * Finally, you can exhaustively match on the contained variant and branch into + * different code paths depending on which type is contained. This is preferred + * to manually checking every variant type T with is<T>() because it provides + * compile-time checking that you handled every type, rather than runtime + * assertion failures. + * + * // Bad! + * char* foo(Variant<A, B, C, D>& v) { + * if (v.is<A>()) { + * return ...; + * } else if (v.is<B>()) { + * return ...; + * } else { + * return doSomething(v.as<C>()); // Forgot about case D! + * } + * } + * + * // Instead, a single function object (that can deal with all possible + * // options) may be provided: + * struct FooMatcher + * { + * // The return type of all matchers must be identical. + * char* operator()(A& a) { ... } + * char* operator()(B& b) { ... } + * char* operator()(C& c) { ... } + * char* operator()(D& d) { ... } // Compile-time error to forget D! + * } + * char* foo(Variant<A, B, C, D>& v) { + * return v.match(FooMatcher()); + * } + * + * // In some situations, a single generic lambda may also be appropriate: + * char* foo(Variant<A, B, C, D>& v) { + * return v.match([](auto&) {...}); + * } + * + * // Alternatively, multiple function objects may be provided, each one + * // corresponding to an option, in the same order: + * char* foo(Variant<A, B, C, D>& v) { + * return v.match([](A&) { ... }, + * [](B&) { ... }, + * [](C&) { ... }, + * [](D&) { ... }); + * } + * + * // In rare cases, the index of the currently-active alternative is + * // needed, it may be obtained by adding a first parameter in the matcner + * // callback, which will receive the index in its most compact type (just + * // use `size_t` if the exact type is not important), e.g.: + * char* foo(Variant<A, B, C, D>& v) { + * return v.match([](auto aIndex, auto& aAlternative) {...}); + * // --OR-- + * return v.match([](size_t aIndex, auto& aAlternative) {...}); + * } + * + * ## Examples + * + * A tree is either an empty leaf, or a node with a value and two children: + * + * struct Leaf { }; + * + * template<typename T> + * struct Node + * { + * T value; + * Tree<T>* left; + * Tree<T>* right; + * }; + * + * template<typename T> + * using Tree = Variant<Leaf, Node<T>>; + * + * A copy-on-write string is either a non-owning reference to some existing + * string, or an owning reference to our copy: + * + * class CopyOnWriteString + * { + * Variant<const char*, UniquePtr<char[]>> string; + * + * ... + * }; + * + * Because Variant must be aligned suitable to hold any value stored within it, + * and because |alignas| requirements don't affect platform ABI with respect to + * how parameters are laid out in memory, Variant can't be used as the type of a + * function parameter. Pass Variant to functions by pointer or reference + * instead. + */ +template <typename... Ts> +class MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS MOZ_NON_PARAM Variant { + friend struct IPC::ParamTraits<mozilla::Variant<Ts...>>; + friend struct mozilla::ipc::IPDLParamTraits<mozilla::Variant<Ts...>>; + + using Tag = typename detail::VariantTag<Ts...>::Type; + using Impl = detail::VariantImplementation<Tag, 0, Ts...>; + + static constexpr size_t RawDataAlignment = tl::Max<alignof(Ts)...>::value; + static constexpr size_t RawDataSize = tl::Max<sizeof(Ts)...>::value; + + // Raw storage for the contained variant value. + alignas(RawDataAlignment) unsigned char rawData[RawDataSize]; + + // Each type is given a unique tag value that lets us keep track of the + // contained variant value's type. + Tag tag; + + // Some versions of GCC treat it as a -Wstrict-aliasing violation (ergo a + // -Werror compile error) to reinterpret_cast<> |rawData| to |T*|, even + // through |void*|. Placing the latter cast in these separate functions + // breaks the chain such that affected GCC versions no longer warn/error. + void* ptr() { return rawData; } + + const void* ptr() const { return rawData; } + + public: + /** Perfect forwarding construction for some variant type T. */ + template <typename RefT, + // RefT captures both const& as well as && (as intended, to support + // perfect forwarding), so we have to remove those qualifiers here + // when ensuring that T is a variant of this type, and getting T's + // tag, etc. + typename T = typename detail::SelectVariantType<RefT, Ts...>::Type> + explicit Variant(RefT&& aT) : tag(Impl::template tag<T>()) { + static_assert( + detail::SelectVariantType<RefT, Ts...>::count == 1, + "Variant can only be selected by type if that type is unique"); + ::new (KnownNotNull, ptr()) T(std::forward<RefT>(aT)); + } + + /** + * Perfect forwarding construction for some variant type T, by + * explicitly giving the type. + * This is necessary to construct from any number of arguments, + * or to convert from a type that is not in the Variant's type list. + */ + template <typename T, typename... Args> + MOZ_IMPLICIT Variant(const VariantType<T>&, Args&&... aTs) + : tag(Impl::template tag<T>()) { + ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...); + } + + /** + * Perfect forwarding construction for some variant type T, by + * explicitly giving the type index. + * This is necessary to construct from any number of arguments, + * or to convert from a type that is not in the Variant's type list, + * or to construct a type that is present more than once in the Variant. + */ + template <size_t N, typename... Args> + MOZ_IMPLICIT Variant(const VariantIndex<N>&, Args&&... aTs) : tag(N) { + using T = typename detail::Nth<N, Ts...>::Type; + ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...); + } + + /** + * Constructs this Variant from an AsVariantTemporary<T> such that T can be + * stored in one of the types allowable in this Variant. This is used in the + * implementation of AsVariant(). + */ + template <typename RefT> + MOZ_IMPLICIT Variant(detail::AsVariantTemporary<RefT>&& aValue) + : tag(Impl::template tag< + typename detail::SelectVariantType<RefT, Ts...>::Type>()) { + using T = typename detail::SelectVariantType<RefT, Ts...>::Type; + static_assert( + detail::SelectVariantType<RefT, Ts...>::count == 1, + "Variant can only be selected by type if that type is unique"); + ::new (KnownNotNull, ptr()) T(std::move(aValue.mValue)); + } + + /** Copy construction. */ + Variant(const Variant& aRhs) : tag(aRhs.tag) { + Impl::copyConstruct(ptr(), aRhs); + } + + /** Move construction. */ + Variant(Variant&& aRhs) : tag(aRhs.tag) { + Impl::moveConstruct(ptr(), std::move(aRhs)); + } + + /** Copy assignment. */ + Variant& operator=(const Variant& aRhs) { + MOZ_ASSERT(&aRhs != this, "self-assign disallowed"); + this->~Variant(); + ::new (KnownNotNull, this) Variant(aRhs); + return *this; + } + + /** Move assignment. */ + Variant& operator=(Variant&& aRhs) { + MOZ_ASSERT(&aRhs != this, "self-assign disallowed"); + this->~Variant(); + ::new (KnownNotNull, this) Variant(std::move(aRhs)); + return *this; + } + + /** Move assignment from AsVariant(). */ + template <typename T> + Variant& operator=(detail::AsVariantTemporary<T>&& aValue) { + static_assert( + detail::SelectVariantType<T, Ts...>::count == 1, + "Variant can only be selected by type if that type is unique"); + this->~Variant(); + ::new (KnownNotNull, this) Variant(std::move(aValue)); + return *this; + } + + ~Variant() { Impl::destroy(*this); } + + template <typename T, typename... Args> + T& emplace(Args&&... aTs) { + Impl::destroy(*this); + tag = Impl::template tag<T>(); + ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...); + return as<T>(); + } + + template <size_t N, typename... Args> + typename detail::Nth<N, Ts...>::Type& emplace(Args&&... aTs) { + using T = typename detail::Nth<N, Ts...>::Type; + Impl::destroy(*this); + tag = N; + ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...); + return as<N>(); + } + + /** Check which variant type is currently contained. */ + template <typename T> + bool is() const { + static_assert( + detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not uniquely found in this Variant's type list"); + return Impl::template tag<T>() == tag; + } + + template <size_t N> + bool is() const { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + return N == size_t(tag); + } + + /** + * Operator == overload that defers to the variant type's operator== + * implementation if the rhs is tagged as the same type as this one. + */ + bool operator==(const Variant& aRhs) const { + return tag == aRhs.tag && Impl::equal(*this, aRhs); + } + + /** + * Operator != overload that defers to the negation of the variant type's + * operator== implementation if the rhs is tagged as the same type as this + * one. + */ + bool operator!=(const Variant& aRhs) const { return !(*this == aRhs); } + + // Accessors for working with the contained variant value. + + /** Mutable lvalue-reference. */ + template <typename T> + T& as() & { + static_assert( + detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not uniquely found in this Variant's type list"); + MOZ_RELEASE_ASSERT(is<T>()); + return *static_cast<T*>(ptr()); + } + + template <size_t N> + typename detail::Nth<N, Ts...>::Type& as() & { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + MOZ_RELEASE_ASSERT(is<N>()); + return *static_cast<typename detail::Nth<N, Ts...>::Type*>(ptr()); + } + + /** Immutable const lvalue-reference. */ + template <typename T> + const T& as() const& { + static_assert(detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not found in this Variant's type list"); + MOZ_RELEASE_ASSERT(is<T>()); + return *static_cast<const T*>(ptr()); + } + + template <size_t N> + const typename detail::Nth<N, Ts...>::Type& as() const& { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + MOZ_RELEASE_ASSERT(is<N>()); + return *static_cast<const typename detail::Nth<N, Ts...>::Type*>(ptr()); + } + + /** Mutable rvalue-reference. */ + template <typename T> + T&& as() && { + static_assert( + detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not uniquely found in this Variant's type list"); + MOZ_RELEASE_ASSERT(is<T>()); + return std::move(*static_cast<T*>(ptr())); + } + + template <size_t N> + typename detail::Nth<N, Ts...>::Type&& as() && { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + MOZ_RELEASE_ASSERT(is<N>()); + return std::move( + *static_cast<typename detail::Nth<N, Ts...>::Type*>(ptr())); + } + + /** Immutable const rvalue-reference. */ + template <typename T> + const T&& as() const&& { + static_assert(detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not found in this Variant's type list"); + MOZ_RELEASE_ASSERT(is<T>()); + return std::move(*static_cast<const T*>(ptr())); + } + + template <size_t N> + const typename detail::Nth<N, Ts...>::Type&& as() const&& { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + MOZ_RELEASE_ASSERT(is<N>()); + return std::move( + *static_cast<const typename detail::Nth<N, Ts...>::Type*>(ptr())); + } + + /** + * Extract the contained variant value from this container into a temporary + * value. On completion, the value in the variant will be in a + * safely-destructible state, as determined by the behavior of T's move + * constructor when provided the variant's internal value. + */ + template <typename T> + T extract() { + static_assert( + detail::SelectVariantType<T, Ts...>::count == 1, + "provided a type not uniquely found in this Variant's type list"); + MOZ_ASSERT(is<T>()); + return T(std::move(as<T>())); + } + + template <size_t N> + typename detail::Nth<N, Ts...>::Type extract() { + static_assert(N < sizeof...(Ts), + "provided an index outside of this Variant's type list"); + MOZ_RELEASE_ASSERT(is<N>()); + return typename detail::Nth<N, Ts...>::Type(std::move(as<N>())); + } + + // Exhaustive matching of all variant types on the contained value. + + /** Match on an immutable const lvalue-reference. */ + template <typename Matcher> + decltype(auto) match(Matcher&& aMatcher) const& { + return Impl::match(std::forward<Matcher>(aMatcher), *this); + } + + template <typename M0, typename M1, typename... Ms> + decltype(auto) match(M0&& aM0, M1&& aM1, Ms&&... aMs) const& { + return matchN(*this, std::forward<M0>(aM0), std::forward<M1>(aM1), + std::forward<Ms>(aMs)...); + } + + /** Match on a mutable non-const lvalue-reference. */ + template <typename Matcher> + decltype(auto) match(Matcher&& aMatcher) & { + return Impl::match(std::forward<Matcher>(aMatcher), *this); + } + + template <typename M0, typename M1, typename... Ms> + decltype(auto) match(M0&& aM0, M1&& aM1, Ms&&... aMs) & { + return matchN(*this, std::forward<M0>(aM0), std::forward<M1>(aM1), + std::forward<Ms>(aMs)...); + } + + /** Match on an immutable const rvalue-reference. */ + template <typename Matcher> + decltype(auto) match(Matcher&& aMatcher) const&& { + return Impl::match(std::forward<Matcher>(aMatcher), std::move(*this)); + } + + template <typename M0, typename M1, typename... Ms> + decltype(auto) match(M0&& aM0, M1&& aM1, Ms&&... aMs) const&& { + return matchN(std::move(*this), std::forward<M0>(aM0), + std::forward<M1>(aM1), std::forward<Ms>(aMs)...); + } + + /** Match on a mutable non-const rvalue-reference. */ + template <typename Matcher> + decltype(auto) match(Matcher&& aMatcher) && { + return Impl::match(std::forward<Matcher>(aMatcher), std::move(*this)); + } + + template <typename M0, typename M1, typename... Ms> + decltype(auto) match(M0&& aM0, M1&& aM1, Ms&&... aMs) && { + return matchN(std::move(*this), std::forward<M0>(aM0), + std::forward<M1>(aM1), std::forward<Ms>(aMs)...); + } + + /** + * Incorporate the current variant's tag into hashValue. + * Note that this does not hash the actual contents; you must take + * care of that yourself, perhaps by using a match. + */ + mozilla::HashNumber addTagToHash(mozilla::HashNumber hashValue) const { + return mozilla::AddToHash(hashValue, tag); + } + + private: + template <typename ConcreteVariant, typename M0, typename M1, typename... Ms> + static decltype(auto) matchN(ConcreteVariant&& aVariant, M0&& aM0, M1&& aM1, + Ms&&... aMs) { + static_assert( + 2 + sizeof...(Ms) == sizeof...(Ts), + "Variant<T...>::match() takes either one callable argument that " + "accepts every type T; or one for each type T, in order"); + return Impl::matchN(std::forward<ConcreteVariant>(aVariant), + std::forward<M0>(aM0), std::forward<M1>(aM1), + std::forward<Ms>(aMs)...); + } +}; + +/* + * AsVariant() is used to construct a Variant<T,...> value containing the + * provided T value using type inference. It can be used to construct Variant + * values in expressions or return them from functions without specifying the + * entire Variant type. + * + * Because AsVariant() must copy or move the value into a temporary and this + * cannot necessarily be elided by the compiler, it's mostly appropriate only + * for use with primitive or very small types. + * + * AsVariant() returns a AsVariantTemporary value which is implicitly + * convertible to any Variant that can hold a value of type T. + */ +template <typename T> +detail::AsVariantTemporary<T> AsVariant(T&& aValue) { + return detail::AsVariantTemporary<T>(std::forward<T>(aValue)); +} + +} // namespace mozilla + +#endif /* mozilla_Variant_h */ |