You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by ap...@apache.org on 2019/05/06 15:50:02 UTC
[arrow] branch master updated: ARROW-5252: [C++] Use
standard-compliant std::variant backport
This is an automated email from the ASF dual-hosted git repository.
apitrou pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow.git
The following commit(s) were added to refs/heads/master by this push:
new 89a18b5 ARROW-5252: [C++] Use standard-compliant std::variant backport
89a18b5 is described below
commit 89a18b5381ed0148065c994df1108d9632135086
Author: Antoine Pitrou <an...@python.org>
AuthorDate: Mon May 6 17:49:51 2019 +0200
ARROW-5252: [C++] Use standard-compliant std::variant backport
Replace mapbox::variant with Michael Park's variant implementation.
Author: Antoine Pitrou <an...@python.org>
Closes #4259 from pitrou/ARROW-5252-variant-backport and squashes the following commits:
03dbc0e14 <Antoine Pitrou> ARROW-5252: Use standard-compliant std::variant backport
---
LICENSE.txt | 59 +-
c_glib/gandiva-glib/node.cpp | 2 +-
cpp/src/arrow/compute/kernel.h | 7 +-
cpp/src/arrow/scalar.h | 1 -
cpp/src/arrow/util/variant.h | 12 +-
cpp/src/arrow/vendored/CMakeLists.txt | 1 -
cpp/src/arrow/vendored/variant.hpp | 2815 ++++++++++++++++++++
cpp/src/arrow/vendored/variant/CMakeLists.txt | 18 -
.../arrow/vendored/variant/recursive_wrapper.hpp | 124 -
cpp/src/arrow/vendored/variant/variant.hpp | 1029 -------
cpp/src/arrow/vendored/variant/variant_io.hpp | 47 -
cpp/src/arrow/vendored/variant/variant_visitor.hpp | 40 -
cpp/src/gandiva/CMakeLists.txt | 1 +
cpp/src/gandiva/expr_validator.cc | 2 +-
cpp/src/gandiva/like_holder.cc | 2 +-
.../{literal_holder.h => literal_holder.cc} | 34 +-
cpp/src/gandiva/literal_holder.h | 3 +
cpp/src/gandiva/llvm_generator.cc | 34 +-
cpp/src/gandiva/node.h | 6 +-
cpp/src/gandiva/to_date_holder.cc | 4 +-
20 files changed, 2906 insertions(+), 1335 deletions(-)
diff --git a/LICENSE.txt b/LICENSE.txt
index d66d4ba..42600fc 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -406,37 +406,6 @@ DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
-This project includes code from the mapbox/variant project, BSD 3-clause
-license
-
-Copyright (c) MapBox
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-- Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-- Redistributions in binary form must reproduce the above copyright notice, this
- list of conditions and the following disclaimer in the documentation and/or
- other materials provided with the distribution.
-- Neither the name "MapBox" nor the names of its contributors may be
- used to endorse or promote products derived from this software without
- specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
This project includes code from the FlatBuffers project
Copyright 2014 Google Inc.
@@ -709,6 +678,34 @@ DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
+The file cpp/src/arrow/vendored/variant.hpp has the following license
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+
The files in cpp/src/arrow/vendored/xxhash/ have the following license
(BSD 2-Clause License)
diff --git a/c_glib/gandiva-glib/node.cpp b/c_glib/gandiva-glib/node.cpp
index 0c47a7c..6d0f3aa 100644
--- a/c_glib/gandiva-glib/node.cpp
+++ b/c_glib/gandiva-glib/node.cpp
@@ -33,7 +33,7 @@ ggandiva_literal_node_get(GGandivaLiteralNode *node)
{
auto gandiva_literal_node =
std::static_pointer_cast<gandiva::LiteralNode>(ggandiva_node_get_raw(GGANDIVA_NODE(node)));
- return gandiva_literal_node->holder().get<Type>();
+ return arrow::util::get<Type>(gandiva_literal_node->holder());
}
G_BEGIN_DECLS
diff --git a/cpp/src/arrow/compute/kernel.h b/cpp/src/arrow/compute/kernel.h
index 56d7d68..aba659e 100644
--- a/cpp/src/arrow/compute/kernel.h
+++ b/cpp/src/arrow/compute/kernel.h
@@ -117,6 +117,11 @@ struct ARROW_EXPORT Datum {
Datum(const Datum& other) noexcept { this->value = other.value; }
+ Datum& operator=(const Datum& other) noexcept {
+ value = other.value;
+ return *this;
+ }
+
// Define move constructor and move assignment, for better performance
Datum(Datum&& other) noexcept : value(std::move(other.value)) {}
@@ -126,7 +131,7 @@ struct ARROW_EXPORT Datum {
}
Datum::type kind() const {
- switch (this->value.which()) {
+ switch (this->value.index()) {
case 0:
return Datum::NONE;
case 1:
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index ce714bf..82ef4d5 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -30,7 +30,6 @@
#include "arrow/type_fwd.h"
#include "arrow/type_traits.h"
#include "arrow/util/decimal.h"
-#include "arrow/util/variant.h"
#include "arrow/util/visibility.h"
namespace arrow {
diff --git a/cpp/src/arrow/util/variant.h b/cpp/src/arrow/util/variant.h
index fecaa51..29e52be 100644
--- a/cpp/src/arrow/util/variant.h
+++ b/cpp/src/arrow/util/variant.h
@@ -18,16 +18,16 @@
#ifndef ARROW_UTIL_VARIANT_H
#define ARROW_UTIL_VARIANT_H
-#include "arrow/vendored/variant/variant.hpp" // IWYU pragma: export
-#include "arrow/vendored/variant/variant_io.hpp"
+#include "arrow/vendored/variant.hpp" // IWYU pragma: export
namespace arrow {
namespace util {
-using mapbox::util::apply_visitor; // seems akin to std::visit
-using mapbox::util::bad_variant_access;
-using mapbox::util::get;
-using mapbox::util::variant;
+using ::mpark::bad_variant_access;
+using ::mpark::get;
+using ::mpark::get_if;
+using ::mpark::variant;
+using ::mpark::visit;
} // namespace util
} // namespace arrow
diff --git a/cpp/src/arrow/vendored/CMakeLists.txt b/cpp/src/arrow/vendored/CMakeLists.txt
index 4cda3f8..4ee54e8 100644
--- a/cpp/src/arrow/vendored/CMakeLists.txt
+++ b/cpp/src/arrow/vendored/CMakeLists.txt
@@ -18,4 +18,3 @@
arrow_install_all_headers("arrow/vendored")
add_subdirectory(datetime)
-add_subdirectory(variant)
diff --git a/cpp/src/arrow/vendored/variant.hpp b/cpp/src/arrow/vendored/variant.hpp
new file mode 100644
index 0000000..8af0bfe
--- /dev/null
+++ b/cpp/src/arrow/vendored/variant.hpp
@@ -0,0 +1,2815 @@
+// Vendored from v1.4.0, from single-header branch at https://github.com/mpark/variant
+
+// MPark.Variant
+//
+// Copyright Michael Park, 2015-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#ifndef MPARK_VARIANT_HPP
+#define MPARK_VARIANT_HPP
+
+/*
+ variant synopsis
+
+namespace std {
+
+ // 20.7.2, class template variant
+ template <class... Types>
+ class variant {
+ public:
+
+ // 20.7.2.1, constructors
+ constexpr variant() noexcept(see below);
+ variant(const variant&);
+ variant(variant&&) noexcept(see below);
+
+ template <class T> constexpr variant(T&&) noexcept(see below);
+
+ template <class T, class... Args>
+ constexpr explicit variant(in_place_type_t<T>, Args&&...);
+
+ template <class T, class U, class... Args>
+ constexpr explicit variant(
+ in_place_type_t<T>, initializer_list<U>, Args&&...);
+
+ template <size_t I, class... Args>
+ constexpr explicit variant(in_place_index_t<I>, Args&&...);
+
+ template <size_t I, class U, class... Args>
+ constexpr explicit variant(
+ in_place_index_t<I>, initializer_list<U>, Args&&...);
+
+ // 20.7.2.2, destructor
+ ~variant();
+
+ // 20.7.2.3, assignment
+ variant& operator=(const variant&);
+ variant& operator=(variant&&) noexcept(see below);
+
+ template <class T> variant& operator=(T&&) noexcept(see below);
+
+ // 20.7.2.4, modifiers
+ template <class T, class... Args>
+ T& emplace(Args&&...);
+
+ template <class T, class U, class... Args>
+ T& emplace(initializer_list<U>, Args&&...);
+
+ template <size_t I, class... Args>
+ variant_alternative<I, variant>& emplace(Args&&...);
+
+ template <size_t I, class U, class... Args>
+ variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...);
+
+ // 20.7.2.5, value status
+ constexpr bool valueless_by_exception() const noexcept;
+ constexpr size_t index() const noexcept;
+
+ // 20.7.2.6, swap
+ void swap(variant&) noexcept(see below);
+ };
+
+ // 20.7.3, variant helper classes
+ template <class T> struct variant_size; // undefined
+
+ template <class T>
+ constexpr size_t variant_size_v = variant_size<T>::value;
+
+ template <class T> struct variant_size<const T>;
+ template <class T> struct variant_size<volatile T>;
+ template <class T> struct variant_size<const volatile T>;
+
+ template <class... Types>
+ struct variant_size<variant<Types...>>;
+
+ template <size_t I, class T> struct variant_alternative; // undefined
+
+ template <size_t I, class T>
+ using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+ template <size_t I, class T> struct variant_alternative<I, const T>;
+ template <size_t I, class T> struct variant_alternative<I, volatile T>;
+ template <size_t I, class T> struct variant_alternative<I, const volatile T>;
+
+ template <size_t I, class... Types>
+ struct variant_alternative<I, variant<Types...>>;
+
+ constexpr size_t variant_npos = -1;
+
+ // 20.7.4, value access
+ template <class T, class... Types>
+ constexpr bool holds_alternative(const variant<Types...>&) noexcept;
+
+ template <size_t I, class... Types>
+ constexpr variant_alternative_t<I, variant<Types...>>&
+ get(variant<Types...>&);
+
+ template <size_t I, class... Types>
+ constexpr variant_alternative_t<I, variant<Types...>>&&
+ get(variant<Types...>&&);
+
+ template <size_t I, class... Types>
+ constexpr variant_alternative_t<I, variant<Types...>> const&
+ get(const variant<Types...>&);
+
+ template <size_t I, class... Types>
+ constexpr variant_alternative_t<I, variant<Types...>> const&&
+ get(const variant<Types...>&&);
+
+ template <class T, class... Types>
+ constexpr T& get(variant<Types...>&);
+
+ template <class T, class... Types>
+ constexpr T&& get(variant<Types...>&&);
+
+ template <class T, class... Types>
+ constexpr const T& get(const variant<Types...>&);
+
+ template <class T, class... Types>
+ constexpr const T&& get(const variant<Types...>&&);
+
+ template <size_t I, class... Types>
+ constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
+ get_if(variant<Types...>*) noexcept;
+
+ template <size_t I, class... Types>
+ constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
+ get_if(const variant<Types...>*) noexcept;
+
+ template <class T, class... Types>
+ constexpr add_pointer_t<T>
+ get_if(variant<Types...>*) noexcept;
+
+ template <class T, class... Types>
+ constexpr add_pointer_t<const T>
+ get_if(const variant<Types...>*) noexcept;
+
+ // 20.7.5, relational operators
+ template <class... Types>
+ constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
+
+ template <class... Types>
+ constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
+
+ template <class... Types>
+ constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
+
+ template <class... Types>
+ constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
+
+ template <class... Types>
+ constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
+
+ template <class... Types>
+ constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
+
+ // 20.7.6, visitation
+ template <class Visitor, class... Variants>
+ constexpr see below visit(Visitor&&, Variants&&...);
+
+ // 20.7.7, class monostate
+ struct monostate;
+
+ // 20.7.8, monostate relational operators
+ constexpr bool operator<(monostate, monostate) noexcept;
+ constexpr bool operator>(monostate, monostate) noexcept;
+ constexpr bool operator<=(monostate, monostate) noexcept;
+ constexpr bool operator>=(monostate, monostate) noexcept;
+ constexpr bool operator==(monostate, monostate) noexcept;
+ constexpr bool operator!=(monostate, monostate) noexcept;
+
+ // 20.7.9, specialized algorithms
+ template <class... Types>
+ void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
+
+ // 20.7.10, class bad_variant_access
+ class bad_variant_access;
+
+ // 20.7.11, hash support
+ template <class T> struct hash;
+ template <class... Types> struct hash<variant<Types...>>;
+ template <> struct hash<monostate>;
+
+} // namespace std
+
+*/
+
+#include <cstddef>
+#include <exception>
+#include <functional>
+#include <initializer_list>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+// MPark.Variant
+//
+// Copyright Michael Park, 2015-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#ifndef MPARK_CONFIG_HPP
+#define MPARK_CONFIG_HPP
+
+// MSVC 2015 Update 3.
+#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210)
+#error "MPark.Variant requires C++11 support."
+#endif
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#ifndef __has_include
+#define __has_include(x) 0
+#endif
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+#if __has_attribute(always_inline) || defined(__GNUC__)
+#define MPARK_ALWAYS_INLINE __attribute__((__always_inline__)) inline
+#elif defined(_MSC_VER)
+#define MPARK_ALWAYS_INLINE __forceinline
+#else
+#define MPARK_ALWAYS_INLINE inline
+#endif
+
+#if __has_builtin(__builtin_addressof) || \
+ (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
+#define MPARK_BUILTIN_ADDRESSOF
+#endif
+
+#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
+#define MPARK_BUILTIN_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+#define MPARK_BUILTIN_UNREACHABLE __assume(false)
+#else
+#define MPARK_BUILTIN_UNREACHABLE
+#endif
+
+#if __has_builtin(__type_pack_element)
+#define MPARK_TYPE_PACK_ELEMENT
+#endif
+
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \
+ !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
+#define MPARK_CPP11_CONSTEXPR
+#endif
+
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#define MPARK_CPP14_CONSTEXPR
+#endif
+
+#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \
+ (defined(_MSC_VER) && defined(_CPPUNWIND))
+#define MPARK_EXCEPTIONS
+#endif
+
+#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
+#define MPARK_GENERIC_LAMBDAS
+#endif
+
+#if defined(__cpp_lib_integer_sequence)
+#define MPARK_INTEGER_SEQUENCE
+#endif
+
+#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
+#define MPARK_RETURN_TYPE_DEDUCTION
+#endif
+
+#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
+#define MPARK_TRANSPARENT_OPERATORS
+#endif
+
+#if defined(__cpp_variable_templates) || defined(_MSC_VER)
+#define MPARK_VARIABLE_TEMPLATES
+#endif
+
+#if !defined(__GLIBCXX__) || __has_include(<codecvt>) // >= libstdc++-5
+#define MPARK_TRIVIALITY_TYPE_TRAITS
+#define MPARK_INCOMPLETE_TYPE_TRAITS
+#endif
+
+#endif // MPARK_CONFIG_HPP
+
+// MPark.Variant
+//
+// Copyright Michael Park, 2015-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#ifndef MPARK_IN_PLACE_HPP
+#define MPARK_IN_PLACE_HPP
+
+#include <cstddef>
+
+
+namespace mpark {
+
+ struct in_place_t { explicit in_place_t() = default; };
+
+ template <std::size_t I>
+ struct in_place_index_t { explicit in_place_index_t() = default; };
+
+ template <typename T>
+ struct in_place_type_t { explicit in_place_type_t() = default; };
+
+#ifdef MPARK_VARIABLE_TEMPLATES
+ constexpr in_place_t in_place{};
+
+ template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
+
+ template <typename T> constexpr in_place_type_t<T> in_place_type{};
+#endif
+
+} // namespace mpark
+
+#endif // MPARK_IN_PLACE_HPP
+
+// MPark.Variant
+//
+// Copyright Michael Park, 2015-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#ifndef MPARK_LIB_HPP
+#define MPARK_LIB_HPP
+
+#include <memory>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+
+#define MPARK_RETURN(...) \
+ noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
+
+namespace mpark {
+ namespace lib {
+ template <typename T>
+ struct identity { using type = T; };
+
+ inline namespace cpp14 {
+ template <typename T, std::size_t N>
+ struct array {
+ constexpr const T &operator[](std::size_t index) const {
+ return data[index];
+ }
+
+ T data[N == 0 ? 1 : N];
+ };
+
+ template <typename T>
+ using add_pointer_t = typename std::add_pointer<T>::type;
+
+ template <typename... Ts>
+ using common_type_t = typename std::common_type<Ts...>::type;
+
+ template <typename T>
+ using decay_t = typename std::decay<T>::type;
+
+ template <bool B, typename T = void>
+ using enable_if_t = typename std::enable_if<B, T>::type;
+
+ template <typename T>
+ using remove_const_t = typename std::remove_const<T>::type;
+
+ template <typename T>
+ using remove_reference_t = typename std::remove_reference<T>::type;
+
+ template <typename T>
+ inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
+ return static_cast<T &&>(t);
+ }
+
+ template <typename T>
+ inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
+ static_assert(!std::is_lvalue_reference<T>::value,
+ "can not forward an rvalue as an lvalue");
+ return static_cast<T &&>(t);
+ }
+
+ template <typename T>
+ inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
+ return static_cast<remove_reference_t<T> &&>(t);
+ }
+
+#ifdef MPARK_INTEGER_SEQUENCE
+ using std::integer_sequence;
+ using std::index_sequence;
+ using std::make_index_sequence;
+ using std::index_sequence_for;
+#else
+ template <typename T, T... Is>
+ struct integer_sequence {
+ using value_type = T;
+ static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+ };
+
+ template <std::size_t... Is>
+ using index_sequence = integer_sequence<std::size_t, Is...>;
+
+ template <typename Lhs, typename Rhs>
+ struct make_index_sequence_concat;
+
+ template <std::size_t... Lhs, std::size_t... Rhs>
+ struct make_index_sequence_concat<index_sequence<Lhs...>,
+ index_sequence<Rhs...>>
+ : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
+
+ template <std::size_t N>
+ struct make_index_sequence_impl;
+
+ template <std::size_t N>
+ using make_index_sequence = typename make_index_sequence_impl<N>::type;
+
+ template <std::size_t N>
+ struct make_index_sequence_impl
+ : make_index_sequence_concat<make_index_sequence<N / 2>,
+ make_index_sequence<N - (N / 2)>> {};
+
+ template <>
+ struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
+
+ template <>
+ struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
+
+ template <typename... Ts>
+ using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+#endif
+
+ // <functional>
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using equal_to = std::equal_to<>;
+#else
+ struct equal_to {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
+ };
+#endif
+
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using not_equal_to = std::not_equal_to<>;
+#else
+ struct not_equal_to {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
+ };
+#endif
+
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using less = std::less<>;
+#else
+ struct less {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
+ };
+#endif
+
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using greater = std::greater<>;
+#else
+ struct greater {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
+ };
+#endif
+
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using less_equal = std::less_equal<>;
+#else
+ struct less_equal {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
+ };
+#endif
+
+#ifdef MPARK_TRANSPARENT_OPERATORS
+ using greater_equal = std::greater_equal<>;
+#else
+ struct greater_equal {
+ template <typename Lhs, typename Rhs>
+ inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+ MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
+ };
+#endif
+ } // namespace cpp14
+
+ inline namespace cpp17 {
+
+ // <type_traits>
+ template <bool B>
+ using bool_constant = std::integral_constant<bool, B>;
+
+ template <typename...>
+ struct voider : identity<void> {};
+
+ template <typename... Ts>
+ using void_t = typename voider<Ts...>::type;
+
+ namespace detail {
+ namespace swappable {
+
+ using std::swap;
+
+ template <typename T>
+ struct is_swappable {
+ private:
+ template <typename U,
+ typename = decltype(swap(std::declval<U &>(),
+ std::declval<U &>()))>
+ inline static std::true_type test(int);
+
+ template <typename U>
+ inline static std::false_type test(...);
+
+ public:
+ static constexpr bool value = decltype(test<T>(0))::value;
+ };
+
+ template <bool IsSwappable, typename T>
+ struct is_nothrow_swappable {
+ static constexpr bool value =
+ noexcept(swap(std::declval<T &>(), std::declval<T &>()));
+ };
+
+ template <typename T>
+ struct is_nothrow_swappable<false, T> : std::false_type {};
+
+ } // namespace swappable
+ } // namespace detail
+
+ using detail::swappable::is_swappable;
+
+ template <typename T>
+ using is_nothrow_swappable =
+ detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
+
+ // <functional>
+ namespace detail {
+
+ template <typename T>
+ struct is_reference_wrapper : std::false_type {};
+
+ template <typename T>
+ struct is_reference_wrapper<std::reference_wrapper<T>>
+ : std::true_type {};
+
+ template <bool, int>
+ struct Invoke;
+
+ template <>
+ struct Invoke<true /* pmf */, 0 /* is_base_of */> {
+ template <typename R, typename T, typename Arg, typename... Args>
+ inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+ MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
+ };
+
+ template <>
+ struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
+ template <typename R, typename T, typename Arg, typename... Args>
+ inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+ MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
+ };
+
+ template <>
+ struct Invoke<true /* pmf */, 2 /* otherwise */> {
+ template <typename R, typename T, typename Arg, typename... Args>
+ inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+ MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
+ };
+
+ template <>
+ struct Invoke<false /* pmo */, 0 /* is_base_of */> {
+ template <typename R, typename T, typename Arg>
+ inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+ MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
+ };
+
+ template <>
+ struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
+ template <typename R, typename T, typename Arg>
+ inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+ MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
+ };
+
+ template <>
+ struct Invoke<false /* pmo */, 2 /* otherwise */> {
+ template <typename R, typename T, typename Arg>
+ inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+ MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
+ };
+
+ template <typename R, typename T, typename Arg, typename... Args>
+ inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args)
+ MPARK_RETURN(
+ Invoke<std::is_function<R>::value,
+ (std::is_base_of<T, lib::decay_t<Arg>>::value
+ ? 0
+ : is_reference_wrapper<lib::decay_t<Arg>>::value
+ ? 1
+ : 2)>::invoke(f,
+ lib::forward<Arg>(arg),
+ lib::forward<Args>(args)...))
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+ template <typename F, typename... Args>
+ inline constexpr auto invoke(F &&f, Args &&... args)
+ MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+ } // namespace detail
+
+ template <typename F, typename... Args>
+ inline constexpr auto invoke(F &&f, Args &&... args)
+ MPARK_RETURN(detail::invoke(lib::forward<F>(f),
+ lib::forward<Args>(args)...))
+
+ namespace detail {
+
+ template <typename Void, typename, typename...>
+ struct invoke_result {};
+
+ template <typename F, typename... Args>
+ struct invoke_result<void_t<decltype(lib::invoke(
+ std::declval<F>(), std::declval<Args>()...))>,
+ F,
+ Args...>
+ : identity<decltype(
+ lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
+
+ } // namespace detail
+
+ template <typename F, typename... Args>
+ using invoke_result = detail::invoke_result<void, F, Args...>;
+
+ template <typename F, typename... Args>
+ using invoke_result_t = typename invoke_result<F, Args...>::type;
+
+ namespace detail {
+
+ template <typename Void, typename, typename...>
+ struct is_invocable : std::false_type {};
+
+ template <typename F, typename... Args>
+ struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
+ : std::true_type {};
+
+ template <typename Void, typename, typename, typename...>
+ struct is_invocable_r : std::false_type {};
+
+ template <typename R, typename F, typename... Args>
+ struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
+ R,
+ F,
+ Args...>
+ : std::is_convertible<invoke_result_t<F, Args...>, R> {};
+
+ } // namespace detail
+
+ template <typename F, typename... Args>
+ using is_invocable = detail::is_invocable<void, F, Args...>;
+
+ template <typename R, typename F, typename... Args>
+ using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
+
+ namespace detail {
+
+ template <bool Invocable, typename F, typename... Args>
+ struct is_nothrow_invocable {
+ static constexpr bool value =
+ noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
+ };
+
+ template <typename F, typename... Args>
+ struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
+
+ template <bool Invocable, typename R, typename F, typename... Args>
+ struct is_nothrow_invocable_r {
+ private:
+ inline static R impl() {
+ return lib::invoke(std::declval<F>(), std::declval<Args>()...);
+ }
+
+ public:
+ static constexpr bool value = noexcept(impl());
+ };
+
+ template <typename R, typename F, typename... Args>
+ struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
+
+ } // namespace detail
+
+ template <typename F, typename... Args>
+ using is_nothrow_invocable = detail::
+ is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
+
+ template <typename R, typename F, typename... Args>
+ using is_nothrow_invocable_r =
+ detail::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value,
+ R,
+ F,
+ Args...>;
+
+ // <memory>
+#ifdef MPARK_BUILTIN_ADDRESSOF
+ template <typename T>
+ inline constexpr T *addressof(T &arg) noexcept {
+ return __builtin_addressof(arg);
+ }
+#else
+ namespace detail {
+
+ namespace has_addressof_impl {
+
+ struct fail;
+
+ template <typename T>
+ inline fail operator&(T &&);
+
+ template <typename T>
+ inline static constexpr bool impl() {
+ return (std::is_class<T>::value || std::is_union<T>::value) &&
+ !std::is_same<decltype(&std::declval<T &>()), fail>::value;
+ }
+
+ } // namespace has_addressof_impl
+
+ template <typename T>
+ using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
+
+ template <typename T>
+ inline constexpr T *addressof(T &arg, std::true_type) noexcept {
+ return std::addressof(arg);
+ }
+
+ template <typename T>
+ inline constexpr T *addressof(T &arg, std::false_type) noexcept {
+ return &arg;
+ }
+
+ } // namespace detail
+
+ template <typename T>
+ inline constexpr T *addressof(T &arg) noexcept {
+ return detail::addressof(arg, detail::has_addressof<T>{});
+ }
+#endif
+
+ template <typename T>
+ inline constexpr T *addressof(const T &&) = delete;
+
+ } // namespace cpp17
+
+ template <typename T>
+ struct remove_all_extents : identity<T> {};
+
+ template <typename T, std::size_t N>
+ struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
+
+ template <typename T>
+ using remove_all_extents_t = typename remove_all_extents<T>::type;
+
+ template <std::size_t N>
+ using size_constant = std::integral_constant<std::size_t, N>;
+
+ template <std::size_t I, typename T>
+ struct indexed_type : size_constant<I> { using type = T; };
+
+ template <bool... Bs>
+ using all = std::is_same<integer_sequence<bool, true, Bs...>,
+ integer_sequence<bool, Bs..., true>>;
+
+#ifdef MPARK_TYPE_PACK_ELEMENT
+ template <std::size_t I, typename... Ts>
+ using type_pack_element_t = __type_pack_element<I, Ts...>;
+#else
+ template <std::size_t I, typename... Ts>
+ struct type_pack_element_impl {
+ private:
+ template <typename>
+ struct set;
+
+ template <std::size_t... Is>
+ struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
+
+ template <typename T>
+ inline static std::enable_if<true, T> impl(indexed_type<I, T>);
+
+ inline static std::enable_if<false> impl(...);
+
+ public:
+ using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
+ };
+
+ template <std::size_t I, typename... Ts>
+ using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
+
+ template <std::size_t I, typename... Ts>
+ using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
+#endif
+
+#ifdef MPARK_TRIVIALITY_TYPE_TRAITS
+ using std::is_trivially_copy_constructible;
+ using std::is_trivially_move_constructible;
+ using std::is_trivially_copy_assignable;
+ using std::is_trivially_move_assignable;
+#else
+ template <typename T>
+ struct is_trivially_copy_constructible
+ : bool_constant<
+ std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
+
+ template <typename T>
+ struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
+
+ template <typename T>
+ struct is_trivially_copy_assignable
+ : bool_constant<
+ std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
+
+ template <typename T>
+ struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
+#endif
+
+ template <typename T, bool>
+ struct dependent_type : T {};
+
+ template <typename Is, std::size_t J>
+ struct push_back;
+
+ template <typename Is, std::size_t J>
+ using push_back_t = typename push_back<Is, J>::type;
+
+ template <std::size_t... Is, std::size_t J>
+ struct push_back<index_sequence<Is...>, J> {
+ using type = index_sequence<Is..., J>;
+ };
+
+ } // namespace lib
+} // namespace mpark
+
+#undef MPARK_RETURN
+
+#endif // MPARK_LIB_HPP
+
+
+namespace mpark {
+
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+
+#define AUTO auto
+#define AUTO_RETURN(...) { return __VA_ARGS__; }
+
+#define AUTO_REFREF auto &&
+#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
+
+#define DECLTYPE_AUTO decltype(auto)
+#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
+
+#else
+
+#define AUTO auto
+#define AUTO_RETURN(...) \
+ -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
+
+#define AUTO_REFREF auto
+#define AUTO_REFREF_RETURN(...) \
+ -> decltype((__VA_ARGS__)) { \
+ static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
+ return __VA_ARGS__; \
+ }
+
+#define DECLTYPE_AUTO auto
+#define DECLTYPE_AUTO_RETURN(...) \
+ -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
+
+#endif
+
+ class bad_variant_access : public std::exception {
+ public:
+ virtual const char *what() const noexcept override { return "bad_variant_access"; }
+ };
+
+ [[noreturn]] inline void throw_bad_variant_access() {
+#ifdef MPARK_EXCEPTIONS
+ throw bad_variant_access{};
+#else
+ std::terminate();
+ MPARK_BUILTIN_UNREACHABLE;
+#endif
+ }
+
+ template <typename... Ts>
+ class variant;
+
+ template <typename T>
+ struct variant_size;
+
+#ifdef MPARK_VARIABLE_TEMPLATES
+ template <typename T>
+ constexpr std::size_t variant_size_v = variant_size<T>::value;
+#endif
+
+ template <typename T>
+ struct variant_size<const T> : variant_size<T> {};
+
+ template <typename T>
+ struct variant_size<volatile T> : variant_size<T> {};
+
+ template <typename T>
+ struct variant_size<const volatile T> : variant_size<T> {};
+
+ template <typename... Ts>
+ struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
+
+ template <std::size_t I, typename T>
+ struct variant_alternative;
+
+ template <std::size_t I, typename T>
+ using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+ template <std::size_t I, typename T>
+ struct variant_alternative<I, const T>
+ : std::add_const<variant_alternative_t<I, T>> {};
+
+ template <std::size_t I, typename T>
+ struct variant_alternative<I, volatile T>
+ : std::add_volatile<variant_alternative_t<I, T>> {};
+
+ template <std::size_t I, typename T>
+ struct variant_alternative<I, const volatile T>
+ : std::add_cv<variant_alternative_t<I, T>> {};
+
+ template <std::size_t I, typename... Ts>
+ struct variant_alternative<I, variant<Ts...>> {
+ static_assert(I < sizeof...(Ts),
+ "index out of bounds in `std::variant_alternative<>`");
+ using type = lib::type_pack_element_t<I, Ts...>;
+ };
+
+ constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
+
+ namespace detail {
+
+ constexpr std::size_t not_found = static_cast<std::size_t>(-1);
+ constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
+
+#ifdef MPARK_CPP14_CONSTEXPR
+ template <typename T, typename... Ts>
+ inline constexpr std::size_t find_index() {
+ constexpr lib::array<bool, sizeof...(Ts)> matches = {
+ {std::is_same<T, Ts>::value...}
+ };
+ std::size_t result = not_found;
+ for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
+ if (matches[i]) {
+ if (result != not_found) {
+ return ambiguous;
+ }
+ result = i;
+ }
+ }
+ return result;
+ }
+#else
+ inline constexpr std::size_t find_index_impl(std::size_t result,
+ std::size_t) {
+ return result;
+ }
+
+ template <typename... Bs>
+ inline constexpr std::size_t find_index_impl(std::size_t result,
+ std::size_t idx,
+ bool b,
+ Bs... bs) {
+ return b ? (result != not_found ? ambiguous
+ : find_index_impl(idx, idx + 1, bs...))
+ : find_index_impl(result, idx + 1, bs...);
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr std::size_t find_index() {
+ return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
+ }
+#endif
+
+ template <std::size_t I>
+ using find_index_sfinae_impl =
+ lib::enable_if_t<I != not_found && I != ambiguous,
+ lib::size_constant<I>>;
+
+ template <typename T, typename... Ts>
+ using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
+
+ template <std::size_t I>
+ struct find_index_checked_impl : lib::size_constant<I> {
+ static_assert(I != not_found, "the specified type is not found.");
+ static_assert(I != ambiguous, "the specified type is ambiguous.");
+ };
+
+ template <typename T, typename... Ts>
+ using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
+
+ struct valueless_t {};
+
+ enum class Trait { TriviallyAvailable, Available, Unavailable };
+
+ template <typename T,
+ template <typename> class IsTriviallyAvailable,
+ template <typename> class IsAvailable>
+ inline constexpr Trait trait() {
+ return IsTriviallyAvailable<T>::value
+ ? Trait::TriviallyAvailable
+ : IsAvailable<T>::value ? Trait::Available
+ : Trait::Unavailable;
+ }
+
+#ifdef MPARK_CPP14_CONSTEXPR
+ template <typename... Traits>
+ inline constexpr Trait common_trait(Traits... traits_) {
+ Trait result = Trait::TriviallyAvailable;
+ lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
+ for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
+ Trait t = traits[i];
+ if (static_cast<int>(t) > static_cast<int>(result)) {
+ result = t;
+ }
+ }
+ return result;
+ }
+#else
+ inline constexpr Trait common_trait_impl(Trait result) { return result; }
+
+ template <typename... Traits>
+ inline constexpr Trait common_trait_impl(Trait result,
+ Trait t,
+ Traits... ts) {
+ return static_cast<int>(t) > static_cast<int>(result)
+ ? common_trait_impl(t, ts...)
+ : common_trait_impl(result, ts...);
+ }
+
+ template <typename... Traits>
+ inline constexpr Trait common_trait(Traits... ts) {
+ return common_trait_impl(Trait::TriviallyAvailable, ts...);
+ }
+#endif
+
+ template <typename... Ts>
+ struct traits {
+ static constexpr Trait copy_constructible_trait =
+ common_trait(trait<Ts,
+ lib::is_trivially_copy_constructible,
+ std::is_copy_constructible>()...);
+
+ static constexpr Trait move_constructible_trait =
+ common_trait(trait<Ts,
+ lib::is_trivially_move_constructible,
+ std::is_move_constructible>()...);
+
+ static constexpr Trait copy_assignable_trait =
+ common_trait(copy_constructible_trait,
+ trait<Ts,
+ lib::is_trivially_copy_assignable,
+ std::is_copy_assignable>()...);
+
+ static constexpr Trait move_assignable_trait =
+ common_trait(move_constructible_trait,
+ trait<Ts,
+ lib::is_trivially_move_assignable,
+ std::is_move_assignable>()...);
+
+ static constexpr Trait destructible_trait =
+ common_trait(trait<Ts,
+ std::is_trivially_destructible,
+ std::is_destructible>()...);
+ };
+
+ namespace access {
+
+ struct recursive_union {
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+ template <typename V>
+ inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
+ return lib::forward<V>(v).head_;
+ }
+
+ template <typename V, std::size_t I>
+ inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
+ return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
+ }
+#else
+ template <std::size_t I, bool Dummy = true>
+ struct get_alt_impl {
+ template <typename V>
+ inline constexpr AUTO_REFREF operator()(V &&v) const
+ AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
+ };
+
+ template <bool Dummy>
+ struct get_alt_impl<0, Dummy> {
+ template <typename V>
+ inline constexpr AUTO_REFREF operator()(V &&v) const
+ AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
+ };
+
+ template <typename V, std::size_t I>
+ inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
+ AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
+#endif
+ };
+
+ struct base {
+ template <std::size_t I, typename V>
+ inline static constexpr AUTO_REFREF get_alt(V &&v)
+#ifdef _MSC_VER
+ AUTO_REFREF_RETURN(recursive_union::get_alt(
+ lib::forward<V>(v).data_, in_place_index_t<I>{}))
+#else
+ AUTO_REFREF_RETURN(recursive_union::get_alt(
+ data(lib::forward<V>(v)), in_place_index_t<I>{}))
+#endif
+ };
+
+ struct variant {
+ template <std::size_t I, typename V>
+ inline static constexpr AUTO_REFREF get_alt(V &&v)
+ AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
+ };
+
+ } // namespace access
+
+ namespace visitation {
+
+#if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER)
+#define MPARK_VARIANT_SWITCH_VISIT
+#endif
+
+ struct base {
+ template <typename Visitor, typename... Vs>
+ using dispatch_result_t = decltype(
+ lib::invoke(std::declval<Visitor>(),
+ access::base::get_alt<0>(std::declval<Vs>())...));
+
+ template <typename Expected>
+ struct expected {
+ template <typename Actual>
+ inline static constexpr bool but_got() {
+ return std::is_same<Expected, Actual>::value;
+ }
+ };
+
+ template <typename Expected, typename Actual>
+ struct visit_return_type_check {
+ static_assert(
+ expected<Expected>::template but_got<Actual>(),
+ "`visit` requires the visitor to have a single return type");
+
+ template <typename Visitor, typename... Alts>
+ inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
+ Alts &&... alts)
+ DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
+ lib::forward<Alts>(alts)...))
+ };
+
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+ template <bool B, typename R, typename... ITs>
+ struct dispatcher;
+
+ template <typename R, typename... ITs>
+ struct dispatcher<false, R, ITs...> {
+ template <std::size_t B, typename F, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch(
+ F &&, typename ITs::type &&..., Vs &&...) {
+ MPARK_BUILTIN_UNREACHABLE;
+ }
+
+ template <std::size_t I, typename F, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) {
+ MPARK_BUILTIN_UNREACHABLE;
+ }
+
+ template <std::size_t B, typename F, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t,
+ F &&,
+ Vs &&...) {
+ MPARK_BUILTIN_UNREACHABLE;
+ }
+ };
+
+ template <typename R, typename... ITs>
+ struct dispatcher<true, R, ITs...> {
+ template <std::size_t B, typename F>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch(
+ F &&f, typename ITs::type &&... visited_vs) {
+ using Expected = R;
+ using Actual = decltype(lib::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<ITs::value>(
+ lib::forward<typename ITs::type>(visited_vs))...));
+ return visit_return_type_check<Expected, Actual>::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<ITs::value>(
+ lib::forward<typename ITs::type>(visited_vs))...);
+ }
+
+ template <std::size_t B, typename F, typename V, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch(
+ F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) {
+#define MPARK_DISPATCH(I) \
+ dispatcher<(I < lib::decay_t<V>::size()), \
+ R, \
+ ITs..., \
+ lib::indexed_type<I, V>>:: \
+ template dispatch<0>(lib::forward<F>(f), \
+ lib::forward<typename ITs::type>(visited_vs)..., \
+ lib::forward<V>(v), \
+ lib::forward<Vs>(vs)...)
+
+#define MPARK_DEFAULT(I) \
+ dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>( \
+ lib::forward<F>(f), \
+ lib::forward<typename ITs::type>(visited_vs)..., \
+ lib::forward<V>(v), \
+ lib::forward<Vs>(vs)...)
+
+ switch (v.index()) {
+ case B + 0: return MPARK_DISPATCH(B + 0);
+ case B + 1: return MPARK_DISPATCH(B + 1);
+ case B + 2: return MPARK_DISPATCH(B + 2);
+ case B + 3: return MPARK_DISPATCH(B + 3);
+ case B + 4: return MPARK_DISPATCH(B + 4);
+ case B + 5: return MPARK_DISPATCH(B + 5);
+ case B + 6: return MPARK_DISPATCH(B + 6);
+ case B + 7: return MPARK_DISPATCH(B + 7);
+ case B + 8: return MPARK_DISPATCH(B + 8);
+ case B + 9: return MPARK_DISPATCH(B + 9);
+ case B + 10: return MPARK_DISPATCH(B + 10);
+ case B + 11: return MPARK_DISPATCH(B + 11);
+ case B + 12: return MPARK_DISPATCH(B + 12);
+ case B + 13: return MPARK_DISPATCH(B + 13);
+ case B + 14: return MPARK_DISPATCH(B + 14);
+ case B + 15: return MPARK_DISPATCH(B + 15);
+ case B + 16: return MPARK_DISPATCH(B + 16);
+ case B + 17: return MPARK_DISPATCH(B + 17);
+ case B + 18: return MPARK_DISPATCH(B + 18);
+ case B + 19: return MPARK_DISPATCH(B + 19);
+ case B + 20: return MPARK_DISPATCH(B + 20);
+ case B + 21: return MPARK_DISPATCH(B + 21);
+ case B + 22: return MPARK_DISPATCH(B + 22);
+ case B + 23: return MPARK_DISPATCH(B + 23);
+ case B + 24: return MPARK_DISPATCH(B + 24);
+ case B + 25: return MPARK_DISPATCH(B + 25);
+ case B + 26: return MPARK_DISPATCH(B + 26);
+ case B + 27: return MPARK_DISPATCH(B + 27);
+ case B + 28: return MPARK_DISPATCH(B + 28);
+ case B + 29: return MPARK_DISPATCH(B + 29);
+ case B + 30: return MPARK_DISPATCH(B + 30);
+ case B + 31: return MPARK_DISPATCH(B + 31);
+ default: return MPARK_DEFAULT(B + 32);
+ }
+
+#undef MPARK_DEFAULT
+#undef MPARK_DISPATCH
+ }
+
+ template <std::size_t I, typename F, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f,
+ Vs &&... vs) {
+ using Expected = R;
+ using Actual = decltype(
+ lib::invoke(lib::forward<F>(f),
+ access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+ return visit_return_type_check<Expected, Actual>::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<I>(lib::forward<Vs>(vs))...);
+ }
+
+ template <std::size_t B, typename F, typename V, typename... Vs>
+ MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index,
+ F &&f,
+ V &&v,
+ Vs &&... vs) {
+ static_assert(lib::all<(lib::decay_t<V>::size() ==
+ lib::decay_t<Vs>::size())...>::value,
+ "all of the variants must be the same size.");
+#define MPARK_DISPATCH_AT(I) \
+ dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>( \
+ lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
+
+#define MPARK_DEFAULT(I) \
+ dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>( \
+ index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
+
+ switch (index) {
+ case B + 0: return MPARK_DISPATCH_AT(B + 0);
+ case B + 1: return MPARK_DISPATCH_AT(B + 1);
+ case B + 2: return MPARK_DISPATCH_AT(B + 2);
+ case B + 3: return MPARK_DISPATCH_AT(B + 3);
+ case B + 4: return MPARK_DISPATCH_AT(B + 4);
+ case B + 5: return MPARK_DISPATCH_AT(B + 5);
+ case B + 6: return MPARK_DISPATCH_AT(B + 6);
+ case B + 7: return MPARK_DISPATCH_AT(B + 7);
+ case B + 8: return MPARK_DISPATCH_AT(B + 8);
+ case B + 9: return MPARK_DISPATCH_AT(B + 9);
+ case B + 10: return MPARK_DISPATCH_AT(B + 10);
+ case B + 11: return MPARK_DISPATCH_AT(B + 11);
+ case B + 12: return MPARK_DISPATCH_AT(B + 12);
+ case B + 13: return MPARK_DISPATCH_AT(B + 13);
+ case B + 14: return MPARK_DISPATCH_AT(B + 14);
+ case B + 15: return MPARK_DISPATCH_AT(B + 15);
+ case B + 16: return MPARK_DISPATCH_AT(B + 16);
+ case B + 17: return MPARK_DISPATCH_AT(B + 17);
+ case B + 18: return MPARK_DISPATCH_AT(B + 18);
+ case B + 19: return MPARK_DISPATCH_AT(B + 19);
+ case B + 20: return MPARK_DISPATCH_AT(B + 20);
+ case B + 21: return MPARK_DISPATCH_AT(B + 21);
+ case B + 22: return MPARK_DISPATCH_AT(B + 22);
+ case B + 23: return MPARK_DISPATCH_AT(B + 23);
+ case B + 24: return MPARK_DISPATCH_AT(B + 24);
+ case B + 25: return MPARK_DISPATCH_AT(B + 25);
+ case B + 26: return MPARK_DISPATCH_AT(B + 26);
+ case B + 27: return MPARK_DISPATCH_AT(B + 27);
+ case B + 28: return MPARK_DISPATCH_AT(B + 28);
+ case B + 29: return MPARK_DISPATCH_AT(B + 29);
+ case B + 30: return MPARK_DISPATCH_AT(B + 30);
+ case B + 31: return MPARK_DISPATCH_AT(B + 31);
+ default: return MPARK_DEFAULT(B + 32);
+ }
+
+#undef MPARK_DEFAULT
+#undef MPARK_DISPATCH_AT
+ }
+ };
+#else
+ template <typename T>
+ inline static constexpr const T &at(const T &elem) noexcept {
+ return elem;
+ }
+
+ template <typename T, std::size_t N, typename... Is>
+ inline static constexpr const lib::remove_all_extents_t<T> &at(
+ const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept {
+ return at(elems[i], is...);
+ }
+
+ template <typename F, typename... Fs>
+ inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
+ make_farray(F &&f, Fs &&... fs) {
+ return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
+ }
+
+ template <typename F, typename... Vs>
+ struct make_fmatrix_impl {
+
+ template <std::size_t... Is>
+ inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+ F &&f, Vs &&... vs) {
+ using Expected = dispatch_result_t<F, Vs...>;
+ using Actual = decltype(lib::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
+ return visit_return_type_check<Expected, Actual>::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
+ }
+
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+ template <std::size_t... Is>
+ inline static constexpr auto impl(lib::index_sequence<Is...>) {
+ return &dispatch<Is...>;
+ }
+
+ template <typename Is, std::size_t... Js, typename... Ls>
+ inline static constexpr auto impl(Is,
+ lib::index_sequence<Js...>,
+ Ls... ls) {
+ return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...);
+ }
+#else
+ template <typename...>
+ struct impl;
+
+ template <std::size_t... Is>
+ struct impl<lib::index_sequence<Is...>> {
+ inline constexpr AUTO operator()() const
+ AUTO_RETURN(&dispatch<Is...>)
+ };
+
+ template <typename Is, std::size_t... Js, typename... Ls>
+ struct impl<Is, lib::index_sequence<Js...>, Ls...> {
+ inline constexpr AUTO operator()() const
+ AUTO_RETURN(
+ make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
+ };
+#endif
+ };
+
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+ template <typename F, typename... Vs>
+ inline static constexpr auto make_fmatrix() {
+ return make_fmatrix_impl<F, Vs...>::impl(
+ lib::index_sequence<>{},
+ lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
+ }
+#else
+ template <typename F, typename... Vs>
+ inline static constexpr AUTO make_fmatrix()
+ AUTO_RETURN(
+ typename make_fmatrix_impl<F, Vs...>::template impl<
+ lib::index_sequence<>,
+ lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
+#endif
+
+ template <typename F, typename... Vs>
+ struct make_fdiagonal_impl {
+ template <std::size_t I>
+ inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+ F &&f, Vs &&... vs) {
+ using Expected = dispatch_result_t<F, Vs...>;
+ using Actual = decltype(
+ lib::invoke(lib::forward<F>(f),
+ access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+ return visit_return_type_check<Expected, Actual>::invoke(
+ lib::forward<F>(f),
+ access::base::get_alt<I>(lib::forward<Vs>(vs))...);
+ }
+
+ template <std::size_t... Is>
+ inline static constexpr AUTO impl(lib::index_sequence<Is...>)
+ AUTO_RETURN(make_farray(&dispatch<Is>...))
+ };
+
+ template <typename F, typename V, typename... Vs>
+ inline static constexpr auto make_fdiagonal()
+ -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
+ lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
+ static_assert(lib::all<(lib::decay_t<V>::size() ==
+ lib::decay_t<Vs>::size())...>::value,
+ "all of the variants must be the same size.");
+ return make_fdiagonal_impl<F, V, Vs...>::impl(
+ lib::make_index_sequence<lib::decay_t<V>::size()>{});
+ }
+#endif
+ };
+
+#if !defined(MPARK_VARIANT_SWITCH_VISIT) && \
+ (!defined(_MSC_VER) || _MSC_VER >= 1910)
+ template <typename F, typename... Vs>
+ using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
+
+ template <typename F, typename... Vs>
+ struct fmatrix {
+ static constexpr fmatrix_t<F, Vs...> value =
+ base::make_fmatrix<F, Vs...>();
+ };
+
+ template <typename F, typename... Vs>
+ constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
+
+ template <typename F, typename... Vs>
+ using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
+
+ template <typename F, typename... Vs>
+ struct fdiagonal {
+ static constexpr fdiagonal_t<F, Vs...> value =
+ base::make_fdiagonal<F, Vs...>();
+ };
+
+ template <typename F, typename... Vs>
+ constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
+#endif
+
+ struct alt {
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
+ Vs &&... vs)
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+ DECLTYPE_AUTO_RETURN(
+ base::dispatcher<
+ true,
+ base::dispatch_result_t<Visitor,
+ decltype(as_base(
+ lib::forward<Vs>(vs)))...>>::
+ template dispatch<0>(lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+ DECLTYPE_AUTO_RETURN(base::at(
+ fmatrix<Visitor &&,
+ decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+ vs.index()...)(lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#else
+ DECLTYPE_AUTO_RETURN(base::at(
+ base::make_fmatrix<Visitor &&,
+ decltype(as_base(lib::forward<Vs>(vs)))...>(),
+ vs.index()...)(lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#endif
+
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
+ Visitor &&visitor,
+ Vs &&... vs)
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+ DECLTYPE_AUTO_RETURN(
+ base::dispatcher<
+ true,
+ base::dispatch_result_t<Visitor,
+ decltype(as_base(
+ lib::forward<Vs>(vs)))...>>::
+ template dispatch_at<0>(index,
+ lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+ DECLTYPE_AUTO_RETURN(base::at(
+ fdiagonal<Visitor &&,
+ decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+ index)(lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#else
+ DECLTYPE_AUTO_RETURN(base::at(
+ base::make_fdiagonal<Visitor &&,
+ decltype(as_base(lib::forward<Vs>(vs)))...>(),
+ index)(lib::forward<Visitor>(visitor),
+ as_base(lib::forward<Vs>(vs))...))
+#endif
+ };
+
+ struct variant {
+ private:
+ template <typename Visitor>
+ struct visitor {
+ template <typename... Values>
+ inline static constexpr bool does_not_handle() {
+ return lib::is_invocable<Visitor, Values...>::value;
+ }
+ };
+
+ template <typename Visitor, typename... Values>
+ struct visit_exhaustiveness_check {
+ static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
+ "`visit` requires the visitor to be exhaustive.");
+
+ inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
+ Values &&... values)
+ DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
+ lib::forward<Values>(values)...))
+ };
+
+ template <typename Visitor>
+ struct value_visitor {
+ Visitor &&visitor_;
+
+ template <typename... Alts>
+ inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
+ DECLTYPE_AUTO_RETURN(
+ visit_exhaustiveness_check<
+ Visitor,
+ decltype((lib::forward<Alts>(alts).value))...>::
+ invoke(lib::forward<Visitor>(visitor_),
+ lib::forward<Alts>(alts).value...))
+ };
+
+ template <typename Visitor>
+ inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
+ AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
+
+ public:
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
+ Vs &&... vs)
+ DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
+ lib::forward<Vs>(vs).impl_...))
+
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
+ Visitor &&visitor,
+ Vs &&... vs)
+ DECLTYPE_AUTO_RETURN(
+ alt::visit_alt_at(index,
+ lib::forward<Visitor>(visitor),
+ lib::forward<Vs>(vs).impl_...))
+
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
+ Vs &&... vs)
+ DECLTYPE_AUTO_RETURN(
+ visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
+ lib::forward<Vs>(vs)...))
+
+ template <typename Visitor, typename... Vs>
+ inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
+ Visitor &&visitor,
+ Vs &&... vs)
+ DECLTYPE_AUTO_RETURN(
+ visit_alt_at(index,
+ make_value_visitor(lib::forward<Visitor>(visitor)),
+ lib::forward<Vs>(vs)...))
+ };
+
+ } // namespace visitation
+
+ template <std::size_t Index, typename T>
+ struct alt {
+ using value_type = T;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+ template <typename... Args>
+ inline explicit constexpr alt(in_place_t, Args &&... args)
+ : value(lib::forward<Args>(args)...) {}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+ T value;
+ };
+
+ template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
+ union recursive_union;
+
+ template <Trait DestructibleTrait, std::size_t Index>
+ union recursive_union<DestructibleTrait, Index> {};
+
+#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor) \
+ template <std::size_t Index, typename T, typename... Ts> \
+ union recursive_union<destructible_trait, Index, T, Ts...> { \
+ public: \
+ inline explicit constexpr recursive_union(valueless_t) noexcept \
+ : dummy_{} {} \
+ \
+ template <typename... Args> \
+ inline explicit constexpr recursive_union(in_place_index_t<0>, \
+ Args &&... args) \
+ : head_(in_place_t{}, lib::forward<Args>(args)...) {} \
+ \
+ template <std::size_t I, typename... Args> \
+ inline explicit constexpr recursive_union(in_place_index_t<I>, \
+ Args &&... args) \
+ : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
+ \
+ recursive_union(const recursive_union &) = default; \
+ recursive_union(recursive_union &&) = default; \
+ \
+ destructor \
+ \
+ recursive_union &operator=(const recursive_union &) = default; \
+ recursive_union &operator=(recursive_union &&) = default; \
+ \
+ private: \
+ char dummy_; \
+ alt<Index, T> head_; \
+ recursive_union<destructible_trait, Index + 1, Ts...> tail_; \
+ \
+ friend struct access::recursive_union; \
+ }
+
+ MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
+ ~recursive_union() = default;);
+ MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
+ ~recursive_union() {});
+ MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
+ ~recursive_union() = delete;);
+
+#undef MPARK_VARIANT_RECURSIVE_UNION
+
+ using index_t = unsigned int;
+
+ template <Trait DestructibleTrait, typename... Ts>
+ class base {
+ public:
+ inline explicit constexpr base(valueless_t tag) noexcept
+ : data_(tag), index_(static_cast<index_t>(-1)) {}
+
+ template <std::size_t I, typename... Args>
+ inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
+ : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
+ index_(I) {}
+
+ inline constexpr bool valueless_by_exception() const noexcept {
+ return index_ == static_cast<index_t>(-1);
+ }
+
+ inline constexpr std::size_t index() const noexcept {
+ return valueless_by_exception() ? variant_npos : index_;
+ }
+
+ protected:
+ using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
+
+ friend inline constexpr base &as_base(base &b) { return b; }
+ friend inline constexpr const base &as_base(const base &b) { return b; }
+ friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
+ friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
+
+ friend inline constexpr data_t &data(base &b) { return b.data_; }
+ friend inline constexpr const data_t &data(const base &b) { return b.data_; }
+ friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
+ friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
+
+ inline static constexpr std::size_t size() { return sizeof...(Ts); }
+
+ data_t data_;
+ index_t index_;
+
+ friend struct access::base;
+ friend struct visitation::base;
+ };
+
+ struct dtor {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+ template <typename Alt>
+ inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+ };
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1910
+#define MPARK_INHERITING_CTOR(type, base) using base::base;
+#else
+#define MPARK_INHERITING_CTOR(type, base) \
+ template <typename... Args> \
+ inline explicit constexpr type(Args &&... args) \
+ : base(lib::forward<Args>(args)...) {}
+#endif
+
+ template <typename Traits, Trait = Traits::destructible_trait>
+ class destructor;
+
+#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
+ template <typename... Ts> \
+ class destructor<traits<Ts...>, destructible_trait> \
+ : public base<destructible_trait, Ts...> { \
+ using super = base<destructible_trait, Ts...>; \
+ \
+ public: \
+ MPARK_INHERITING_CTOR(destructor, super) \
+ using super::operator=; \
+ \
+ destructor(const destructor &) = default; \
+ destructor(destructor &&) = default; \
+ definition \
+ destructor &operator=(const destructor &) = default; \
+ destructor &operator=(destructor &&) = default; \
+ \
+ protected: \
+ destroy \
+ }
+
+ MPARK_VARIANT_DESTRUCTOR(
+ Trait::TriviallyAvailable,
+ ~destructor() = default;,
+ inline void destroy() noexcept {
+ this->index_ = static_cast<index_t>(-1);
+ });
+
+ MPARK_VARIANT_DESTRUCTOR(
+ Trait::Available,
+ ~destructor() { destroy(); },
+ inline void destroy() noexcept {
+ if (!this->valueless_by_exception()) {
+ visitation::alt::visit_alt(dtor{}, *this);
+ }
+ this->index_ = static_cast<index_t>(-1);
+ });
+
+ MPARK_VARIANT_DESTRUCTOR(
+ Trait::Unavailable,
+ ~destructor() = delete;,
+ inline void destroy() noexcept = delete;);
+
+#undef MPARK_VARIANT_DESTRUCTOR
+
+ template <typename Traits>
+ class constructor : public destructor<Traits> {
+ using super = destructor<Traits>;
+
+ public:
+ MPARK_INHERITING_CTOR(constructor, super)
+ using super::operator=;
+
+ protected:
+#ifndef MPARK_GENERIC_LAMBDAS
+ struct ctor {
+ template <typename LhsAlt, typename RhsAlt>
+ inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
+ constructor::construct_alt(lhs_alt,
+ lib::forward<RhsAlt>(rhs_alt).value);
+ }
+ };
+#endif
+
+ template <std::size_t I, typename T, typename... Args>
+ inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
+ auto *result = ::new (static_cast<void *>(lib::addressof(a)))
+ alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
+ return result->value;
+ }
+
+ template <typename Rhs>
+ inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
+ lhs.destroy();
+ if (!rhs.valueless_by_exception()) {
+ visitation::alt::visit_alt_at(
+ rhs.index(),
+#ifdef MPARK_GENERIC_LAMBDAS
+ [](auto &lhs_alt, auto &&rhs_alt) {
+ constructor::construct_alt(
+ lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
+ }
+#else
+ ctor{}
+#endif
+ ,
+ lhs,
+ lib::forward<Rhs>(rhs));
+ lhs.index_ = rhs.index_;
+ }
+ }
+ };
+
+ template <typename Traits, Trait = Traits::move_constructible_trait>
+ class move_constructor;
+
+#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
+ template <typename... Ts> \
+ class move_constructor<traits<Ts...>, move_constructible_trait> \
+ : public constructor<traits<Ts...>> { \
+ using super = constructor<traits<Ts...>>; \
+ \
+ public: \
+ MPARK_INHERITING_CTOR(move_constructor, super) \
+ using super::operator=; \
+ \
+ move_constructor(const move_constructor &) = default; \
+ definition \
+ ~move_constructor() = default; \
+ move_constructor &operator=(const move_constructor &) = default; \
+ move_constructor &operator=(move_constructor &&) = default; \
+ }
+
+ MPARK_VARIANT_MOVE_CONSTRUCTOR(
+ Trait::TriviallyAvailable,
+ move_constructor(move_constructor &&that) = default;);
+
+ MPARK_VARIANT_MOVE_CONSTRUCTOR(
+ Trait::Available,
+ move_constructor(move_constructor &&that) noexcept(
+ lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
+ : move_constructor(valueless_t{}) {
+ this->generic_construct(*this, lib::move(that));
+ });
+
+ MPARK_VARIANT_MOVE_CONSTRUCTOR(
+ Trait::Unavailable,
+ move_constructor(move_constructor &&) = delete;);
+
+#undef MPARK_VARIANT_MOVE_CONSTRUCTOR
+
+ template <typename Traits, Trait = Traits::copy_constructible_trait>
+ class copy_constructor;
+
+#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
+ template <typename... Ts> \
+ class copy_constructor<traits<Ts...>, copy_constructible_trait> \
+ : public move_constructor<traits<Ts...>> { \
+ using super = move_constructor<traits<Ts...>>; \
+ \
+ public: \
+ MPARK_INHERITING_CTOR(copy_constructor, super) \
+ using super::operator=; \
+ \
+ definition \
+ copy_constructor(copy_constructor &&) = default; \
+ ~copy_constructor() = default; \
+ copy_constructor &operator=(const copy_constructor &) = default; \
+ copy_constructor &operator=(copy_constructor &&) = default; \
+ }
+
+ MPARK_VARIANT_COPY_CONSTRUCTOR(
+ Trait::TriviallyAvailable,
+ copy_constructor(const copy_constructor &that) = default;);
+
+ MPARK_VARIANT_COPY_CONSTRUCTOR(
+ Trait::Available,
+ copy_constructor(const copy_constructor &that)
+ : copy_constructor(valueless_t{}) {
+ this->generic_construct(*this, that);
+ });
+
+ MPARK_VARIANT_COPY_CONSTRUCTOR(
+ Trait::Unavailable,
+ copy_constructor(const copy_constructor &) = delete;);
+
+#undef MPARK_VARIANT_COPY_CONSTRUCTOR
+
+ template <typename Traits>
+ class assignment : public copy_constructor<Traits> {
+ using super = copy_constructor<Traits>;
+
+ public:
+ MPARK_INHERITING_CTOR(assignment, super)
+ using super::operator=;
+
+ template <std::size_t I, typename... Args>
+ inline /* auto & */ auto emplace(Args &&... args)
+ -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
+ lib::forward<Args>(args)...)) {
+ this->destroy();
+ auto &result = this->construct_alt(access::base::get_alt<I>(*this),
+ lib::forward<Args>(args)...);
+ this->index_ = I;
+ return result;
+ }
+
+ protected:
+#ifndef MPARK_GENERIC_LAMBDAS
+ template <typename That>
+ struct assigner {
+ template <typename ThisAlt, typename ThatAlt>
+ inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
+ self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
+ }
+ assignment *self;
+ };
+#endif
+
+ template <std::size_t I, typename T, typename Arg>
+ inline void assign_alt(alt<I, T> &a, Arg &&arg) {
+ if (this->index() == I) {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+ a.value = lib::forward<Arg>(arg);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+ } else {
+ struct {
+ void operator()(std::true_type) const {
+ this_->emplace<I>(lib::forward<Arg>(arg_));
+ }
+ void operator()(std::false_type) const {
+ this_->emplace<I>(T(lib::forward<Arg>(arg_)));
+ }
+ assignment *this_;
+ Arg &&arg_;
+ } impl{this, lib::forward<Arg>(arg)};
+ impl(lib::bool_constant<
+ std::is_nothrow_constructible<T, Arg>::value ||
+ !std::is_nothrow_move_constructible<T>::value>{});
+ }
+ }
+
+ template <typename That>
+ inline void generic_assign(That &&that) {
+ if (this->valueless_by_exception() && that.valueless_by_exception()) {
+ // do nothing.
+ } else if (that.valueless_by_exception()) {
+ this->destroy();
+ } else {
+ visitation::alt::visit_alt_at(
+ that.index(),
+#ifdef MPARK_GENERIC_LAMBDAS
+ [this](auto &this_alt, auto &&that_alt) {
+ this->assign_alt(
+ this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
+ }
+#else
+ assigner<That>{this}
+#endif
+ ,
+ *this,
+ lib::forward<That>(that));
+ }
+ }
+ };
+
+ template <typename Traits, Trait = Traits::move_assignable_trait>
+ class move_assignment;
+
+#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
+ template <typename... Ts> \
+ class move_assignment<traits<Ts...>, move_assignable_trait> \
+ : public assignment<traits<Ts...>> { \
+ using super = assignment<traits<Ts...>>; \
+ \
+ public: \
+ MPARK_INHERITING_CTOR(move_assignment, super) \
+ using super::operator=; \
+ \
+ move_assignment(const move_assignment &) = default; \
+ move_assignment(move_assignment &&) = default; \
+ ~move_assignment() = default; \
+ move_assignment &operator=(const move_assignment &) = default; \
+ definition \
+ }
+
+ MPARK_VARIANT_MOVE_ASSIGNMENT(
+ Trait::TriviallyAvailable,
+ move_assignment &operator=(move_assignment &&that) = default;);
+
+ MPARK_VARIANT_MOVE_ASSIGNMENT(
+ Trait::Available,
+ move_assignment &
+ operator=(move_assignment &&that) noexcept(
+ lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+ std::is_nothrow_move_assignable<Ts>::value)...>::value) {
+ this->generic_assign(lib::move(that));
+ return *this;
+ });
+
+ MPARK_VARIANT_MOVE_ASSIGNMENT(
+ Trait::Unavailable,
+ move_assignment &operator=(move_assignment &&) = delete;);
+
+#undef MPARK_VARIANT_MOVE_ASSIGNMENT
+
+ template <typename Traits, Trait = Traits::copy_assignable_trait>
+ class copy_assignment;
+
+#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
+ template <typename... Ts> \
+ class copy_assignment<traits<Ts...>, copy_assignable_trait> \
+ : public move_assignment<traits<Ts...>> { \
+ using super = move_assignment<traits<Ts...>>; \
+ \
+ public: \
+ MPARK_INHERITING_CTOR(copy_assignment, super) \
+ using super::operator=; \
+ \
+ copy_assignment(const copy_assignment &) = default; \
+ copy_assignment(copy_assignment &&) = default; \
+ ~copy_assignment() = default; \
+ definition \
+ copy_assignment &operator=(copy_assignment &&) = default; \
+ }
+
+ MPARK_VARIANT_COPY_ASSIGNMENT(
+ Trait::TriviallyAvailable,
+ copy_assignment &operator=(const copy_assignment &that) = default;);
+
+ MPARK_VARIANT_COPY_ASSIGNMENT(
+ Trait::Available,
+ copy_assignment &operator=(const copy_assignment &that) {
+ this->generic_assign(that);
+ return *this;
+ });
+
+ MPARK_VARIANT_COPY_ASSIGNMENT(
+ Trait::Unavailable,
+ copy_assignment &operator=(const copy_assignment &) = delete;);
+
+#undef MPARK_VARIANT_COPY_ASSIGNMENT
+
+ template <typename... Ts>
+ class impl : public copy_assignment<traits<Ts...>> {
+ using super = copy_assignment<traits<Ts...>>;
+
+ public:
+ MPARK_INHERITING_CTOR(impl, super)
+ using super::operator=;
+
+ template <std::size_t I, typename Arg>
+ inline void assign(Arg &&arg) {
+ this->assign_alt(access::base::get_alt<I>(*this),
+ lib::forward<Arg>(arg));
+ }
+
+ inline void swap(impl &that) {
+ if (this->valueless_by_exception() && that.valueless_by_exception()) {
+ // do nothing.
+ } else if (this->index() == that.index()) {
+ visitation::alt::visit_alt_at(this->index(),
+#ifdef MPARK_GENERIC_LAMBDAS
+ [](auto &this_alt, auto &that_alt) {
+ using std::swap;
+ swap(this_alt.value,
+ that_alt.value);
+ }
+#else
+ swapper{}
+#endif
+ ,
+ *this,
+ that);
+ } else {
+ impl *lhs = this;
+ impl *rhs = lib::addressof(that);
+ if (lhs->move_nothrow() && !rhs->move_nothrow()) {
+ std::swap(lhs, rhs);
+ }
+ impl tmp(lib::move(*rhs));
+#ifdef MPARK_EXCEPTIONS
+ // EXTENSION: When the move construction of `lhs` into `rhs` throws
+ // and `tmp` is nothrow move constructible then we move `tmp` back
+ // into `rhs` and provide the strong exception safety guarantee.
+ try {
+ this->generic_construct(*rhs, lib::move(*lhs));
+ } catch (...) {
+ if (tmp.move_nothrow()) {
+ this->generic_construct(*rhs, lib::move(tmp));
+ }
+ throw;
+ }
+#else
+ this->generic_construct(*rhs, lib::move(*lhs));
+#endif
+ this->generic_construct(*lhs, lib::move(tmp));
+ }
+ }
+
+ private:
+#ifndef MPARK_GENERIC_LAMBDAS
+ struct swapper {
+ template <typename ThisAlt, typename ThatAlt>
+ inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
+ using std::swap;
+ swap(this_alt.value, that_alt.value);
+ }
+ };
+#endif
+
+ inline constexpr bool move_nothrow() const {
+ return this->valueless_by_exception() ||
+ lib::array<bool, sizeof...(Ts)>{
+ {std::is_nothrow_move_constructible<Ts>::value...}
+ }[this->index()];
+ }
+ };
+
+#undef MPARK_INHERITING_CTOR
+
+ template <std::size_t I, typename T>
+ struct overload_leaf {
+ using F = lib::size_constant<I> (*)(T);
+ operator F() const { return nullptr; }
+ };
+
+ template <typename... Ts>
+ struct overload_impl {
+ private:
+ template <typename>
+ struct impl;
+
+ template <std::size_t... Is>
+ struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
+
+ public:
+ using type = impl<lib::index_sequence_for<Ts...>>;
+ };
+
+ template <typename... Ts>
+ using overload = typename overload_impl<Ts...>::type;
+
+ template <typename T, typename... Ts>
+ using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
+
+ template <typename T>
+ struct is_in_place_index : std::false_type {};
+
+ template <std::size_t I>
+ struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
+
+ template <typename T>
+ struct is_in_place_type : std::false_type {};
+
+ template <typename T>
+ struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
+
+ } // detail
+
+ template <typename... Ts>
+ class variant {
+ static_assert(0 < sizeof...(Ts),
+ "variant must consist of at least one alternative.");
+
+ static_assert(lib::all<!std::is_array<Ts>::value...>::value,
+ "variant can not have an array type as an alternative.");
+
+ static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
+ "variant can not have a reference type as an alternative.");
+
+ static_assert(lib::all<!std::is_void<Ts>::value...>::value,
+ "variant can not have a void type as an alternative.");
+
+ public:
+ template <
+ typename Front = lib::type_pack_element_t<0, Ts...>,
+ lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
+ inline constexpr variant() noexcept(
+ std::is_nothrow_default_constructible<Front>::value)
+ : impl_(in_place_index_t<0>{}) {}
+
+ variant(const variant &) = default;
+ variant(variant &&) = default;
+
+ template <
+ typename Arg,
+ typename Decayed = lib::decay_t<Arg>,
+ lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
+ lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
+ lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0,
+ std::size_t I = detail::best_match<Arg, Ts...>::value,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
+ inline constexpr variant(Arg &&arg) noexcept(
+ std::is_nothrow_constructible<T, Arg>::value)
+ : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
+
+ template <
+ std::size_t I,
+ typename... Args,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+ inline explicit constexpr variant(
+ in_place_index_t<I>,
+ Args &&... args) noexcept(std::is_nothrow_constructible<T,
+ Args...>::value)
+ : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+
+ template <
+ std::size_t I,
+ typename Up,
+ typename... Args,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<std::is_constructible<T,
+ std::initializer_list<Up> &,
+ Args...>::value,
+ int> = 0>
+ inline explicit constexpr variant(
+ in_place_index_t<I>,
+ std::initializer_list<Up> il,
+ Args &&... args) noexcept(std::
+ is_nothrow_constructible<
+ T,
+ std::initializer_list<Up> &,
+ Args...>::value)
+ : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+
+ template <
+ typename T,
+ typename... Args,
+ std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+ lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+ inline explicit constexpr variant(
+ in_place_type_t<T>,
+ Args &&... args) noexcept(std::is_nothrow_constructible<T,
+ Args...>::value)
+ : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+
+ template <
+ typename T,
+ typename Up,
+ typename... Args,
+ std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+ lib::enable_if_t<std::is_constructible<T,
+ std::initializer_list<Up> &,
+ Args...>::value,
+ int> = 0>
+ inline explicit constexpr variant(
+ in_place_type_t<T>,
+ std::initializer_list<Up> il,
+ Args &&... args) noexcept(std::
+ is_nothrow_constructible<
+ T,
+ std::initializer_list<Up> &,
+ Args...>::value)
+ : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+
+ ~variant() = default;
+
+ variant &operator=(const variant &) = default;
+ variant &operator=(variant &&) = default;
+
+ template <typename Arg,
+ lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
+ int> = 0,
+ std::size_t I = detail::best_match<Arg, Ts...>::value,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
+ std::is_constructible<T, Arg>::value),
+ int> = 0>
+ inline variant &operator=(Arg &&arg) noexcept(
+ (std::is_nothrow_assignable<T &, Arg>::value &&
+ std::is_nothrow_constructible<T, Arg>::value)) {
+ impl_.template assign<I>(lib::forward<Arg>(arg));
+ return *this;
+ }
+
+ template <
+ std::size_t I,
+ typename... Args,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+ inline T &emplace(Args &&... args) {
+ return impl_.template emplace<I>(lib::forward<Args>(args)...);
+ }
+
+ template <
+ std::size_t I,
+ typename Up,
+ typename... Args,
+ typename T = lib::type_pack_element_t<I, Ts...>,
+ lib::enable_if_t<std::is_constructible<T,
+ std::initializer_list<Up> &,
+ Args...>::value,
+ int> = 0>
+ inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
+ return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+ }
+
+ template <
+ typename T,
+ typename... Args,
+ std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+ lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+ inline T &emplace(Args &&... args) {
+ return impl_.template emplace<I>(lib::forward<Args>(args)...);
+ }
+
+ template <
+ typename T,
+ typename Up,
+ typename... Args,
+ std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+ lib::enable_if_t<std::is_constructible<T,
+ std::initializer_list<Up> &,
+ Args...>::value,
+ int> = 0>
+ inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
+ return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+ }
+
+ inline constexpr bool valueless_by_exception() const noexcept {
+ return impl_.valueless_by_exception();
+ }
+
+ inline constexpr std::size_t index() const noexcept {
+ return impl_.index();
+ }
+
+ template <bool Dummy = true,
+ lib::enable_if_t<
+ lib::all<Dummy,
+ (lib::dependent_type<std::is_move_constructible<Ts>,
+ Dummy>::value &&
+ lib::dependent_type<lib::is_swappable<Ts>,
+ Dummy>::value)...>::value,
+ int> = 0>
+ inline void swap(variant &that) noexcept(
+ lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+ lib::is_nothrow_swappable<Ts>::value)...>::value) {
+ impl_.swap(that.impl_);
+ }
+
+ private:
+ detail::impl<Ts...> impl_;
+
+ friend struct detail::access::variant;
+ friend struct detail::visitation::variant;
+ };
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
+ return v.index() == I;
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
+ return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
+ }
+
+ namespace detail {
+ template <std::size_t I, typename V>
+ struct generic_get_impl {
+ constexpr generic_get_impl(int) noexcept {}
+
+ constexpr AUTO_REFREF operator()(V &&v) const
+ AUTO_REFREF_RETURN(
+ access::variant::get_alt<I>(lib::forward<V>(v)).value)
+ };
+
+ template <std::size_t I, typename V>
+ inline constexpr AUTO_REFREF generic_get(V &&v)
+ AUTO_REFREF_RETURN(generic_get_impl<I, V>(
+ holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
+ lib::forward<V>(v)))
+ } // namespace detail
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
+ variant<Ts...> &v) {
+ return detail::generic_get<I>(v);
+ }
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
+ variant<Ts...> &&v) {
+ return detail::generic_get<I>(lib::move(v));
+ }
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
+ const variant<Ts...> &v) {
+ return detail::generic_get<I>(v);
+ }
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
+ const variant<Ts...> &&v) {
+ return detail::generic_get<I>(lib::move(v));
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr T &get(variant<Ts...> &v) {
+ return get<detail::find_index_checked<T, Ts...>::value>(v);
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr T &&get(variant<Ts...> &&v) {
+ return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr const T &get(const variant<Ts...> &v) {
+ return get<detail::find_index_checked<T, Ts...>::value>(v);
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr const T &&get(const variant<Ts...> &&v) {
+ return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
+ }
+
+ namespace detail {
+
+ template <std::size_t I, typename V>
+ inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
+ AUTO_RETURN(v && holds_alternative<I>(*v)
+ ? lib::addressof(access::variant::get_alt<I>(*v).value)
+ : nullptr)
+
+ } // namespace detail
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
+ get_if(variant<Ts...> *v) noexcept {
+ return detail::generic_get_if<I>(v);
+ }
+
+ template <std::size_t I, typename... Ts>
+ inline constexpr lib::add_pointer_t<
+ const variant_alternative_t<I, variant<Ts...>>>
+ get_if(const variant<Ts...> *v) noexcept {
+ return detail::generic_get_if<I>(v);
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr lib::add_pointer_t<T>
+ get_if(variant<Ts...> *v) noexcept {
+ return get_if<detail::find_index_checked<T, Ts...>::value>(v);
+ }
+
+ template <typename T, typename... Ts>
+ inline constexpr lib::add_pointer_t<const T>
+ get_if(const variant<Ts...> *v) noexcept {
+ return get_if<detail::find_index_checked<T, Ts...>::value>(v);
+ }
+
+ namespace detail {
+ template <typename RelOp>
+ struct convert_to_bool {
+ template <typename Lhs, typename Rhs>
+ inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const {
+ static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>,
+ bool>::value,
+ "relational operators must return a type"
+ " implicitly convertible to bool");
+ return lib::invoke(
+ RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
+ }
+ };
+ } // namespace detail
+
+ template <typename... Ts>
+ inline constexpr bool operator==(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using equal_to = detail::convert_to_bool<lib::equal_to>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (lhs.index() != rhs.index()) return false;
+ if (lhs.valueless_by_exception()) return true;
+ return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
+#else
+ return lhs.index() == rhs.index() &&
+ (lhs.valueless_by_exception() ||
+ variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
+#endif
+ }
+
+ template <typename... Ts>
+ inline constexpr bool operator!=(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using not_equal_to = detail::convert_to_bool<lib::not_equal_to>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (lhs.index() != rhs.index()) return true;
+ if (lhs.valueless_by_exception()) return false;
+ return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
+#else
+ return lhs.index() != rhs.index() ||
+ (!lhs.valueless_by_exception() &&
+ variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
+#endif
+ }
+
+ template <typename... Ts>
+ inline constexpr bool operator<(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using less = detail::convert_to_bool<lib::less>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (rhs.valueless_by_exception()) return false;
+ if (lhs.valueless_by_exception()) return true;
+ if (lhs.index() < rhs.index()) return true;
+ if (lhs.index() > rhs.index()) return false;
+ return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
+#else
+ return !rhs.valueless_by_exception() &&
+ (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
+ (lhs.index() == rhs.index() &&
+ variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
+#endif
+ }
+
+ template <typename... Ts>
+ inline constexpr bool operator>(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using greater = detail::convert_to_bool<lib::greater>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (lhs.valueless_by_exception()) return false;
+ if (rhs.valueless_by_exception()) return true;
+ if (lhs.index() > rhs.index()) return true;
+ if (lhs.index() < rhs.index()) return false;
+ return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
+#else
+ return !lhs.valueless_by_exception() &&
+ (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
+ (lhs.index() == rhs.index() &&
+ variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
+#endif
+ }
+
+ template <typename... Ts>
+ inline constexpr bool operator<=(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using less_equal = detail::convert_to_bool<lib::less_equal>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (lhs.valueless_by_exception()) return true;
+ if (rhs.valueless_by_exception()) return false;
+ if (lhs.index() < rhs.index()) return true;
+ if (lhs.index() > rhs.index()) return false;
+ return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
+#else
+ return lhs.valueless_by_exception() ||
+ (!rhs.valueless_by_exception() &&
+ (lhs.index() < rhs.index() ||
+ (lhs.index() == rhs.index() &&
+ variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
+#endif
+ }
+
+ template <typename... Ts>
+ inline constexpr bool operator>=(const variant<Ts...> &lhs,
+ const variant<Ts...> &rhs) {
+ using detail::visitation::variant;
+ using greater_equal = detail::convert_to_bool<lib::greater_equal>;
+#ifdef MPARK_CPP14_CONSTEXPR
+ if (rhs.valueless_by_exception()) return true;
+ if (lhs.valueless_by_exception()) return false;
+ if (lhs.index() > rhs.index()) return true;
+ if (lhs.index() < rhs.index()) return false;
+ return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
+#else
+ return rhs.valueless_by_exception() ||
+ (!lhs.valueless_by_exception() &&
+ (lhs.index() > rhs.index() ||
+ (lhs.index() == rhs.index() &&
+ variant::visit_value_at(
+ lhs.index(), greater_equal{}, lhs, rhs))));
+#endif
+ }
+
+ struct monostate {};
+
+ inline constexpr bool operator<(monostate, monostate) noexcept {
+ return false;
+ }
+
+ inline constexpr bool operator>(monostate, monostate) noexcept {
+ return false;
+ }
+
+ inline constexpr bool operator<=(monostate, monostate) noexcept {
+ return true;
+ }
+
+ inline constexpr bool operator>=(monostate, monostate) noexcept {
+ return true;
+ }
+
+ inline constexpr bool operator==(monostate, monostate) noexcept {
+ return true;
+ }
+
+ inline constexpr bool operator!=(monostate, monostate) noexcept {
+ return false;
+ }
+
+#ifdef MPARK_CPP14_CONSTEXPR
+ namespace detail {
+
+ inline constexpr bool all(std::initializer_list<bool> bs) {
+ for (bool b : bs) {
+ if (!b) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ } // namespace detail
+
+ template <typename Visitor, typename... Vs>
+ inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
+ return (detail::all({!vs.valueless_by_exception()...})
+ ? (void)0
+ : throw_bad_variant_access()),
+ detail::visitation::variant::visit_value(
+ lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
+ }
+#else
+ namespace detail {
+
+ template <std::size_t N>
+ inline constexpr bool all_impl(const lib::array<bool, N> &bs,
+ std::size_t idx) {
+ return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
+ }
+
+ template <std::size_t N>
+ inline constexpr bool all(const lib::array<bool, N> &bs) {
+ return all_impl(bs, 0);
+ }
+
+ } // namespace detail
+
+ template <typename Visitor, typename... Vs>
+ inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
+ DECLTYPE_AUTO_RETURN(
+ (detail::all(
+ lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
+ ? (void)0
+ : throw_bad_variant_access()),
+ detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
+ lib::forward<Vs>(vs)...))
+#endif
+
+ template <typename... Ts>
+ inline auto swap(variant<Ts...> &lhs,
+ variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
+ -> decltype(lhs.swap(rhs)) {
+ lhs.swap(rhs);
+ }
+
+ namespace detail {
+
+ template <typename T, typename...>
+ using enabled_type = T;
+
+ namespace hash {
+
+ template <typename H, typename K>
+ constexpr bool meets_requirements() noexcept {
+ return std::is_copy_constructible<H>::value &&
+ std::is_move_constructible<H>::value &&
+ lib::is_invocable_r<std::size_t, H, const K &>::value;
+ }
+
+ template <typename K>
+ constexpr bool is_enabled() noexcept {
+ using H = std::hash<K>;
+ return meets_requirements<H, K>() &&
+ std::is_default_constructible<H>::value &&
+ std::is_copy_assignable<H>::value &&
+ std::is_move_assignable<H>::value;
+ }
+
+ } // namespace hash
+
+ } // namespace detail
+
+#undef AUTO
+#undef AUTO_RETURN
+
+#undef AUTO_REFREF
+#undef AUTO_REFREF_RETURN
+
+#undef DECLTYPE_AUTO
+#undef DECLTYPE_AUTO_RETURN
+
+} // namespace mpark
+
+namespace std {
+
+ template <typename... Ts>
+ struct hash<mpark::detail::enabled_type<
+ mpark::variant<Ts...>,
+ mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
+ mpark::lib::remove_const_t<Ts>>()...>::value>>> {
+ using argument_type = mpark::variant<Ts...>;
+ using result_type = std::size_t;
+
+ inline result_type operator()(const argument_type &v) const {
+ using mpark::detail::visitation::variant;
+ std::size_t result =
+ v.valueless_by_exception()
+ ? 299792458 // Random value chosen by the universe upon creation
+ : variant::visit_alt(
+#ifdef MPARK_GENERIC_LAMBDAS
+ [](const auto &alt) {
+ using alt_type = mpark::lib::decay_t<decltype(alt)>;
+ using value_type = mpark::lib::remove_const_t<
+ typename alt_type::value_type>;
+ return hash<value_type>{}(alt.value);
+ }
+#else
+ hasher{}
+#endif
+ ,
+ v);
+ return hash_combine(result, hash<std::size_t>{}(v.index()));
+ }
+
+ private:
+#ifndef MPARK_GENERIC_LAMBDAS
+ struct hasher {
+ template <typename Alt>
+ inline std::size_t operator()(const Alt &alt) const {
+ using alt_type = mpark::lib::decay_t<Alt>;
+ using value_type =
+ mpark::lib::remove_const_t<typename alt_type::value_type>;
+ return hash<value_type>{}(alt.value);
+ }
+ };
+#endif
+
+ static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
+ return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
+ }
+ };
+
+ template <>
+ struct hash<mpark::monostate> {
+ using argument_type = mpark::monostate;
+ using result_type = std::size_t;
+
+ inline result_type operator()(const argument_type &) const noexcept {
+ return 66740831; // return a fundamentally attractive random value.
+ }
+ };
+
+} // namespace std
+
+#endif // MPARK_VARIANT_HPP
diff --git a/cpp/src/arrow/vendored/variant/CMakeLists.txt b/cpp/src/arrow/vendored/variant/CMakeLists.txt
deleted file mode 100644
index 9c20655..0000000
--- a/cpp/src/arrow/vendored/variant/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-arrow_install_all_headers("arrow/vendored/variant")
diff --git a/cpp/src/arrow/vendored/variant/recursive_wrapper.hpp b/cpp/src/arrow/vendored/variant/recursive_wrapper.hpp
deleted file mode 100644
index 96b6a3f..0000000
--- a/cpp/src/arrow/vendored/variant/recursive_wrapper.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-// Vendored from https://github.com/mapbox/variant at tag v1.1.5
-
-#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
-#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
-
-// Based on variant/recursive_wrapper.hpp from boost.
-//
-// Original license:
-//
-// Copyright (c) 2002-2003
-// Eric Friedman, Itay Maman
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include <cassert>
-#include <utility>
-
-namespace mapbox {
-namespace util {
-
-template <typename T>
-class recursive_wrapper
-{
-
- T* p_;
-
- void assign(T const& rhs)
- {
- this->get() = rhs;
- }
-
-public:
- using type = T;
-
- /**
- * Default constructor default initializes the internally stored value.
- * For POD types this means nothing is done and the storage is
- * uninitialized.
- *
- * @throws std::bad_alloc if there is insufficient memory for an object
- * of type T.
- * @throws any exception thrown by the default constructur of T.
- */
- recursive_wrapper()
- : p_(new T){}
-
- ~recursive_wrapper() noexcept { delete p_; }
-
- recursive_wrapper(recursive_wrapper const& operand)
- : p_(new T(operand.get())) {}
-
- recursive_wrapper(T const& operand)
- : p_(new T(operand)) {}
-
- recursive_wrapper(recursive_wrapper&& operand)
- : p_(new T(std::move(operand.get()))) {}
-
- recursive_wrapper(T&& operand)
- : p_(new T(std::move(operand))) {}
-
- inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
- {
- assign(rhs.get());
- return *this;
- }
-
- inline recursive_wrapper& operator=(T const& rhs)
- {
- assign(rhs);
- return *this;
- }
-
- inline void swap(recursive_wrapper& operand) noexcept
- {
- T* temp = operand.p_;
- operand.p_ = p_;
- p_ = temp;
- }
-
- recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
- {
- swap(rhs);
- return *this;
- }
-
- recursive_wrapper& operator=(T&& rhs)
- {
- get() = std::move(rhs);
- return *this;
- }
-
- T& get()
- {
- assert(p_);
- return *get_pointer();
- }
-
- T const& get() const
- {
- assert(p_);
- return *get_pointer();
- }
-
- T* get_pointer() { return p_; }
-
- const T* get_pointer() const { return p_; }
-
- operator T const&() const { return this->get(); }
-
- operator T&() { return this->get(); }
-
-}; // class recursive_wrapper
-
-template <typename T>
-inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
-{
- lhs.swap(rhs);
-}
-} // namespace util
-} // namespace mapbox
-
-#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
diff --git a/cpp/src/arrow/vendored/variant/variant.hpp b/cpp/src/arrow/vendored/variant/variant.hpp
deleted file mode 100644
index bb399de..0000000
--- a/cpp/src/arrow/vendored/variant/variant.hpp
+++ /dev/null
@@ -1,1029 +0,0 @@
-// Vendored from https://github.com/mapbox/variant at tag v1.1.5
-
-#ifndef MAPBOX_UTIL_VARIANT_HPP
-#define MAPBOX_UTIL_VARIANT_HPP
-
-#include <cassert>
-#include <cstddef> // size_t
-#include <new> // operator new
-#include <stdexcept> // runtime_error
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-#include <functional>
-
-#include "recursive_wrapper.hpp"
-#include "variant_visitor.hpp"
-
-// clang-format off
-// [[deprecated]] is only available in C++14, use this for the time being
-#if __cplusplus <= 201103L
-# ifdef __GNUC__
-# define MAPBOX_VARIANT_DEPRECATED __attribute__((deprecated))
-# elif defined(_MSC_VER)
-# define MAPBOX_VARIANT_DEPRECATED __declspec(deprecated)
-# else
-# define MAPBOX_VARIANT_DEPRECATED
-# endif
-#else
-# define MAPBOX_VARIANT_DEPRECATED [[deprecated]]
-#endif
-
-
-#ifdef _MSC_VER
-// https://msdn.microsoft.com/en-us/library/bw1hbe6y.aspx
-# ifdef NDEBUG
-# define VARIANT_INLINE __forceinline
-# else
-# define VARIANT_INLINE //__declspec(noinline)
-# endif
-#else
-# ifdef NDEBUG
-# define VARIANT_INLINE //inline __attribute__((always_inline))
-# else
-# define VARIANT_INLINE __attribute__((noinline))
-# endif
-#endif
-// clang-format on
-
-// Exceptions
-#if defined( __EXCEPTIONS) || defined( _MSC_VER)
-#define HAS_EXCEPTIONS
-#endif
-
-#define VARIANT_MAJOR_VERSION 1
-#define VARIANT_MINOR_VERSION 1
-#define VARIANT_PATCH_VERSION 0
-
-#define VARIANT_VERSION (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + (VARIANT_PATCH_VERSION)
-
-namespace mapbox {
-namespace util {
-
-// XXX This should derive from std::logic_error instead of std::runtime_error.
-// See https://github.com/mapbox/variant/issues/48 for details.
-class bad_variant_access : public std::runtime_error
-{
-
-public:
- explicit bad_variant_access(const std::string& what_arg)
- : runtime_error(what_arg) {}
-
- explicit bad_variant_access(const char* what_arg)
- : runtime_error(what_arg) {}
-
-}; // class bad_variant_access
-
-template <typename R = void>
-struct MAPBOX_VARIANT_DEPRECATED static_visitor
-{
- using result_type = R;
-
-protected:
- static_visitor() {}
- ~static_visitor() {}
-};
-
-namespace detail {
-
-static constexpr std::size_t invalid_value = std::size_t(-1);
-
-template <typename T, typename... Types>
-struct direct_type;
-
-template <typename T, typename First, typename... Types>
-struct direct_type<T, First, Types...>
-{
- static constexpr std::size_t index = std::is_same<T, First>::value
- ? sizeof...(Types)
- : direct_type<T, Types...>::index;
-};
-
-template <typename T>
-struct direct_type<T>
-{
- static constexpr std::size_t index = invalid_value;
-};
-
-#if __cpp_lib_logical_traits >= 201510L
-
-using std::conjunction;
-using std::disjunction;
-
-#else
-
-template <typename...>
-struct conjunction : std::true_type {};
-
-template <typename B1>
-struct conjunction<B1> : B1 {};
-
-template <typename B1, typename B2>
-struct conjunction<B1, B2> : std::conditional<B1::value, B2, B1>::type {};
-
-template <typename B1, typename... Bs>
-struct conjunction<B1, Bs...> : std::conditional<B1::value, conjunction<Bs...>, B1>::type {};
-
-template <typename...>
-struct disjunction : std::false_type {};
-
-template <typename B1>
-struct disjunction<B1> : B1 {};
-
-template <typename B1, typename B2>
-struct disjunction<B1, B2> : std::conditional<B1::value, B1, B2>::type {};
-
-template <typename B1, typename... Bs>
-struct disjunction<B1, Bs...> : std::conditional<B1::value, B1, disjunction<Bs...>>::type {};
-
-#endif
-
-template <typename T, typename... Types>
-struct convertible_type;
-
-template <typename T, typename First, typename... Types>
-struct convertible_type<T, First, Types...>
-{
- static constexpr std::size_t index = std::is_convertible<T, First>::value
- ? disjunction<std::is_convertible<T, Types>...>::value ? invalid_value : sizeof...(Types)
- : convertible_type<T, Types...>::index;
-};
-
-template <typename T>
-struct convertible_type<T>
-{
- static constexpr std::size_t index = invalid_value;
-};
-
-template <typename T, typename... Types>
-struct value_traits
-{
- using value_type = typename std::remove_const<typename std::remove_reference<T>::type>::type;
- static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
- static constexpr bool is_direct = direct_index != invalid_value;
- static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
- static constexpr bool is_valid = index != invalid_value;
- static constexpr std::size_t tindex = is_valid ? sizeof...(Types)-index : 0;
- using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
-};
-
-template <typename T, typename R = void>
-struct enable_if_type
-{
- using type = R;
-};
-
-template <typename F, typename V, typename Enable = void>
-struct result_of_unary_visit
-{
- using type = typename std::result_of<F(V&)>::type;
-};
-
-template <typename F, typename V>
-struct result_of_unary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
-{
- using type = typename F::result_type;
-};
-
-template <typename F, typename V, typename Enable = void>
-struct result_of_binary_visit
-{
- using type = typename std::result_of<F(V&, V&)>::type;
-};
-
-template <typename F, typename V>
-struct result_of_binary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
-{
- using type = typename F::result_type;
-};
-
-template <std::size_t arg1, std::size_t... others>
-struct static_max;
-
-template <std::size_t arg>
-struct static_max<arg>
-{
- static const std::size_t value = arg;
-};
-
-template <std::size_t arg1, std::size_t arg2, std::size_t... others>
-struct static_max<arg1, arg2, others...>
-{
- static const std::size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;
-};
-
-template <typename... Types>
-struct variant_helper;
-
-template <typename T, typename... Types>
-struct variant_helper<T, Types...>
-{
- VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
- {
- if (type_index == sizeof...(Types))
- {
- reinterpret_cast<T*>(data)->~T();
- }
- else
- {
- variant_helper<Types...>::destroy(type_index, data);
- }
- }
-
- VARIANT_INLINE static void move(const std::size_t old_type_index, void* old_value, void* new_value)
- {
- if (old_type_index == sizeof...(Types))
- {
- new (new_value) T(std::move(*reinterpret_cast<T*>(old_value)));
- }
- else
- {
- variant_helper<Types...>::move(old_type_index, old_value, new_value);
- }
- }
-
- VARIANT_INLINE static void copy(const std::size_t old_type_index, const void* old_value, void* new_value)
- {
- if (old_type_index == sizeof...(Types))
- {
- new (new_value) T(*reinterpret_cast<const T*>(old_value));
- }
- else
- {
- variant_helper<Types...>::copy(old_type_index, old_value, new_value);
- }
- }
-};
-
-template <>
-struct variant_helper<>
-{
- VARIANT_INLINE static void destroy(const std::size_t, void*) {}
- VARIANT_INLINE static void move(const std::size_t, void*, void*) {}
- VARIANT_INLINE static void copy(const std::size_t, const void*, void*) {}
-};
-
-template <typename T>
-struct unwrapper
-{
- static T const& apply_const(T const& obj) { return obj; }
- static T& apply(T& obj) { return obj; }
-};
-
-template <typename T>
-struct unwrapper<recursive_wrapper<T>>
-{
- static auto apply_const(recursive_wrapper<T> const& obj)
- -> typename recursive_wrapper<T>::type const&
- {
- return obj.get();
- }
- static auto apply(recursive_wrapper<T>& obj)
- -> typename recursive_wrapper<T>::type&
- {
- return obj.get();
- }
-};
-
-template <typename T>
-struct unwrapper<std::reference_wrapper<T>>
-{
- static auto apply_const(std::reference_wrapper<T> const& obj)
- -> typename std::reference_wrapper<T>::type const&
- {
- return obj.get();
- }
- static auto apply(std::reference_wrapper<T>& obj)
- -> typename std::reference_wrapper<T>::type&
- {
- return obj.get();
- }
-};
-
-template <typename F, typename V, typename R, typename... Types>
-struct dispatcher;
-
-template <typename F, typename V, typename R, typename T, typename... Types>
-struct dispatcher<F, V, R, T, Types...>
-{
- VARIANT_INLINE static R apply_const(V const& v, F&& f)
- {
- if (v.template is<T>())
- {
- return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
- }
- else
- {
- return dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
- }
- }
-
- VARIANT_INLINE static R apply(V& v, F&& f)
- {
- if (v.template is<T>())
- {
- return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
- }
- else
- {
- return dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
- }
- }
-};
-
-template <typename F, typename V, typename R, typename T>
-struct dispatcher<F, V, R, T>
-{
- VARIANT_INLINE static R apply_const(V const& v, F&& f)
- {
- return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
- }
-
- VARIANT_INLINE static R apply(V& v, F&& f)
- {
- return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
- }
-};
-
-template <typename F, typename V, typename R, typename T, typename... Types>
-struct binary_dispatcher_rhs;
-
-template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
-struct binary_dispatcher_rhs<F, V, R, T0, T1, Types...>
-{
- VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
- {
- if (rhs.template is<T1>()) // call binary functor
- {
- return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
- unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
- }
- else
- {
- return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
- }
- }
-
- VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
- {
- if (rhs.template is<T1>()) // call binary functor
- {
- return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
- unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
- }
- else
- {
- return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
- }
- }
-};
-
-template <typename F, typename V, typename R, typename T0, typename T1>
-struct binary_dispatcher_rhs<F, V, R, T0, T1>
-{
- VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
- {
- return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
- unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
- }
-
- VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
- {
- return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
- unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
- }
-};
-
-template <typename F, typename V, typename R, typename T, typename... Types>
-struct binary_dispatcher_lhs;
-
-template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
-struct binary_dispatcher_lhs<F, V, R, T0, T1, Types...>
-{
- VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
- {
- if (lhs.template is<T1>()) // call binary functor
- {
- return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
- unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
- }
- else
- {
- return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
- }
- }
-
- VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
- {
- if (lhs.template is<T1>()) // call binary functor
- {
- return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
- unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
- }
- else
- {
- return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
- }
- }
-};
-
-template <typename F, typename V, typename R, typename T0, typename T1>
-struct binary_dispatcher_lhs<F, V, R, T0, T1>
-{
- VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
- {
- return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
- unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
- }
-
- VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
- {
- return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
- unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
- }
-};
-
-template <typename F, typename V, typename R, typename... Types>
-struct binary_dispatcher;
-
-template <typename F, typename V, typename R, typename T, typename... Types>
-struct binary_dispatcher<F, V, R, T, Types...>
-{
- VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
- {
- if (v0.template is<T>())
- {
- if (v1.template is<T>())
- {
- return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
- unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
- }
- else
- {
- return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
- }
- }
- else if (v1.template is<T>())
- {
- return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
- }
- return binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
- }
-
- VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
- {
- if (v0.template is<T>())
- {
- if (v1.template is<T>())
- {
- return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
- unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
- }
- else
- {
- return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
- }
- }
- else if (v1.template is<T>())
- {
- return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
- }
- return binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
- }
-};
-
-template <typename F, typename V, typename R, typename T>
-struct binary_dispatcher<F, V, R, T>
-{
- VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
- {
- return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
- unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
- }
-
- VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
- {
- return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
- unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
- }
-};
-
-// comparator functors
-struct equal_comp
-{
- template <typename T>
- bool operator()(T const& lhs, T const& rhs) const
- {
- return lhs == rhs;
- }
-};
-
-struct less_comp
-{
- template <typename T>
- bool operator()(T const& lhs, T const& rhs) const
- {
- return lhs < rhs;
- }
-};
-
-template <typename Variant, typename Comp>
-class comparer
-{
-public:
- explicit comparer(Variant const& lhs) noexcept
- : lhs_(lhs) {}
- comparer& operator=(comparer const&) = delete;
- // visitor
- template <typename T>
- bool operator()(T const& rhs_content) const
- {
- T const& lhs_content = lhs_.template get_unchecked<T>();
- return Comp()(lhs_content, rhs_content);
- }
-
-private:
- Variant const& lhs_;
-};
-
-// hashing visitor
-struct hasher
-{
- template <typename T>
- std::size_t operator()(const T& hashable) const
- {
- return std::hash<T>{}(hashable);
- }
-};
-
-} // namespace detail
-
-struct no_init
-{
-};
-
-template <typename... Types>
-class variant
-{
- static_assert(sizeof...(Types) > 0, "Template parameter type list of variant can not be empty");
- static_assert(!detail::disjunction<std::is_reference<Types>...>::value, "Variant can not hold reference types. Maybe use std::reference_wrapper?");
-
-private:
- static const std::size_t data_size = detail::static_max<sizeof(Types)...>::value;
- static const std::size_t data_align = detail::static_max<alignof(Types)...>::value;
-public:
- struct adapted_variant_tag;
- using types = std::tuple<Types...>;
-private:
- using first_type = typename std::tuple_element<0, types>::type;
- using data_type = typename std::aligned_storage<data_size, data_align>::type;
- using helper_type = detail::variant_helper<Types...>;
-
- std::size_t type_index;
- data_type data;
-
-public:
- VARIANT_INLINE variant() noexcept(std::is_nothrow_default_constructible<first_type>::value)
- : type_index(sizeof...(Types)-1)
- {
- static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
- new (&data) first_type();
- }
-
- VARIANT_INLINE variant(no_init) noexcept
- : type_index(detail::invalid_value) {}
-
- // http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
- template <typename T, typename Traits = detail::value_traits<T, Types...>,
- typename Enable = typename std::enable_if<Traits::is_valid && !std::is_same<variant<Types...>, typename Traits::value_type>::value>::type >
- VARIANT_INLINE variant(T&& val) noexcept(std::is_nothrow_constructible<typename Traits::target_type, T&&>::value)
- : type_index(Traits::index)
- {
- new (&data) typename Traits::target_type(std::forward<T>(val));
- }
-
- VARIANT_INLINE variant(variant<Types...> const& old)
- : type_index(old.type_index)
- {
- helper_type::copy(old.type_index, &old.data, &data);
- }
-
- VARIANT_INLINE variant(variant<Types...>&& old)
- noexcept(detail::conjunction<std::is_nothrow_move_constructible<Types>...>::value)
- : type_index(old.type_index)
- {
- helper_type::move(old.type_index, &old.data, &data);
- }
-
-private:
- VARIANT_INLINE void copy_assign(variant<Types...> const& rhs)
- {
- helper_type::destroy(type_index, &data);
- type_index = detail::invalid_value;
- helper_type::copy(rhs.type_index, &rhs.data, &data);
- type_index = rhs.type_index;
- }
-
- VARIANT_INLINE void move_assign(variant<Types...>&& rhs)
- {
- helper_type::destroy(type_index, &data);
- type_index = detail::invalid_value;
- helper_type::move(rhs.type_index, &rhs.data, &data);
- type_index = rhs.type_index;
- }
-
-public:
- VARIANT_INLINE variant<Types...>& operator=(variant<Types...>&& other)
- {
- move_assign(std::move(other));
- return *this;
- }
-
- VARIANT_INLINE variant<Types...>& operator=(variant<Types...> const& other)
- {
- copy_assign(other);
- return *this;
- }
-
- // conversions
- // move-assign
- template <typename T>
- VARIANT_INLINE variant<Types...>& operator=(T&& rhs) noexcept
- {
- variant<Types...> temp(std::forward<T>(rhs));
- move_assign(std::move(temp));
- return *this;
- }
-
- // copy-assign
- template <typename T>
- VARIANT_INLINE variant<Types...>& operator=(T const& rhs)
- {
- variant<Types...> temp(rhs);
- copy_assign(temp);
- return *this;
- }
-
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE bool is() const
- {
- return type_index == detail::direct_type<T, Types...>::index;
- }
-
- template <typename T,typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE bool is() const
- {
- return type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index;
- }
-
- VARIANT_INLINE bool valid() const
- {
- return type_index != detail::invalid_value;
- }
-
- template <typename T, typename... Args>
- VARIANT_INLINE void set(Args&&... args)
- {
- helper_type::destroy(type_index, &data);
- type_index = detail::invalid_value;
- new (&data) T(std::forward<Args>(args)...);
- type_index = detail::direct_type<T, Types...>::index;
- }
-
- // get_unchecked<T>()
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get_unchecked()
- {
- return *reinterpret_cast<T*>(&data);
- }
-
-#ifdef HAS_EXCEPTIONS
- // get<T>()
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get()
- {
- if (type_index == detail::direct_type<T, Types...>::index)
- {
- return *reinterpret_cast<T*>(&data);
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get_unchecked() const
- {
- return *reinterpret_cast<T const*>(&data);
- }
-
-#ifdef HAS_EXCEPTIONS
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get() const
- {
- if (type_index == detail::direct_type<T, Types...>::index)
- {
- return *reinterpret_cast<T const*>(&data);
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- // get_unchecked<T>() - T stored as recursive_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get_unchecked()
- {
- return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
- }
-
-#ifdef HAS_EXCEPTIONS
- // get<T>() - T stored as recursive_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get()
- {
- if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
- {
- return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get_unchecked() const
- {
- return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
- }
-
-#ifdef HAS_EXCEPTIONS
- template <typename T, typename std::enable_if<
- (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get() const
- {
- if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
- {
- return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- // get_unchecked<T>() - T stored as std::reference_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get_unchecked()
- {
- return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
- }
-
-#ifdef HAS_EXCEPTIONS
- // get<T>() - T stored as std::reference_wrapper<T>
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T& get()
- {
- if (type_index == detail::direct_type<std::reference_wrapper<T>, Types...>::index)
- {
- return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get_unchecked() const
- {
- return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
- }
-
-#ifdef HAS_EXCEPTIONS
- template <typename T, typename std::enable_if<
- (detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE T const& get() const
- {
- if (type_index == detail::direct_type<std::reference_wrapper<T const>, Types...>::index)
- {
- return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
- }
- else
- {
- throw bad_variant_access("in get<T>()");
- }
- }
-#endif
-
- // This function is deprecated because it returns an internal index field.
- // Use which() instead.
- MAPBOX_VARIANT_DEPRECATED VARIANT_INLINE std::size_t get_type_index() const
- {
- return type_index;
- }
-
- VARIANT_INLINE int which() const noexcept
- {
- return static_cast<int>(sizeof...(Types)-type_index - 1);
- }
-
- template <typename T, typename std::enable_if<
- (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
- VARIANT_INLINE static constexpr int which() noexcept
- {
- return static_cast<int>(sizeof...(Types)-detail::direct_type<T, Types...>::index - 1);
- }
-
- // visitor
- // unary
- template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
- auto VARIANT_INLINE static visit(V const& v, F&& f)
- -> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f)))
- {
- return detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
- }
- // non-const
- template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
- auto VARIANT_INLINE static visit(V& v, F&& f)
- -> decltype(detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
- {
- return detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
- }
-
- // binary
- // const
- template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
- auto VARIANT_INLINE static binary_visit(V const& v0, V const& v1, F&& f)
- -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f)))
- {
- return detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
- }
- // non-const
- template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
- auto VARIANT_INLINE static binary_visit(V& v0, V& v1, F&& f)
- -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f)))
- {
- return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
- }
-
- // match
- // unary
- template <typename... Fs>
- auto VARIANT_INLINE match(Fs&&... fs) const
- -> decltype(variant::visit(*this, ::mapbox::util::make_visitor(std::forward<Fs>(fs)...)))
- {
- return variant::visit(*this, ::mapbox::util::make_visitor(std::forward<Fs>(fs)...));
- }
- // non-const
- template <typename... Fs>
- auto VARIANT_INLINE match(Fs&&... fs)
- -> decltype(variant::visit(*this, ::mapbox::util::make_visitor(std::forward<Fs>(fs)...)))
- {
- return variant::visit(*this, ::mapbox::util::make_visitor(std::forward<Fs>(fs)...));
- }
-
- ~variant() noexcept // no-throw destructor
- {
- helper_type::destroy(type_index, &data);
- }
-
- // comparison operators
- // equality
- VARIANT_INLINE bool operator==(variant const& rhs) const
- {
- assert(valid() && rhs.valid());
- if (this->which() != rhs.which())
- {
- return false;
- }
- detail::comparer<variant, detail::equal_comp> visitor(*this);
- return visit(rhs, visitor);
- }
-
- VARIANT_INLINE bool operator!=(variant const& rhs) const
- {
- return !(*this == rhs);
- }
-
- // less than
- VARIANT_INLINE bool operator<(variant const& rhs) const
- {
- assert(valid() && rhs.valid());
- if (this->which() != rhs.which())
- {
- return this->which() < rhs.which();
- }
- detail::comparer<variant, detail::less_comp> visitor(*this);
- return visit(rhs, visitor);
- }
- VARIANT_INLINE bool operator>(variant const& rhs) const
- {
- return rhs < *this;
- }
- VARIANT_INLINE bool operator<=(variant const& rhs) const
- {
- return !(*this > rhs);
- }
- VARIANT_INLINE bool operator>=(variant const& rhs) const
- {
- return !(*this < rhs);
- }
-};
-
-// unary visitor interface
-// const
-template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V const& v) -> decltype(V::visit(v, std::forward<F>(f)))
-{
- return V::visit(v, std::forward<F>(f));
-}
-
-// non-const
-template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V& v) -> decltype(V::visit(v, std::forward<F>(f)))
-{
- return V::visit(v, std::forward<F>(f));
-}
-
-// binary visitor interface
-// const
-template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
-{
- return V::binary_visit(v0, v1, std::forward<F>(f));
-}
-
-// non-const
-template <typename F, typename V>
-auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
-{
- return V::binary_visit(v0, v1, std::forward<F>(f));
-}
-
-// getter interface
-
-#ifdef HAS_EXCEPTIONS
-template <typename ResultType, typename T>
-auto get(T& var)->decltype(var.template get<ResultType>())
-{
- return var.template get<ResultType>();
-}
-#endif
-
-template <typename ResultType, typename T>
-ResultType& get_unchecked(T& var)
-{
- return var.template get_unchecked<ResultType>();
-}
-
-#ifdef HAS_EXCEPTIONS
-template <typename ResultType, typename T>
-auto get(T const& var)->decltype(var.template get<ResultType>())
-{
- return var.template get<ResultType>();
-}
-#endif
-
-template <typename ResultType, typename T>
-ResultType const& get_unchecked(T const& var)
-{
- return var.template get_unchecked<ResultType>();
-}
-} // namespace util
-} // namespace mapbox
-
-// hashable iff underlying types are hashable
-namespace std {
-template <typename... Types>
-struct hash< ::mapbox::util::variant<Types...>> {
- std::size_t operator()(const ::mapbox::util::variant<Types...>& v) const noexcept
- {
- return ::mapbox::util::apply_visitor(::mapbox::util::detail::hasher{}, v);
- }
-};
-}
-
-#endif // MAPBOX_UTIL_VARIANT_HPP
diff --git a/cpp/src/arrow/vendored/variant/variant_io.hpp b/cpp/src/arrow/vendored/variant/variant_io.hpp
deleted file mode 100644
index 494d2a9..0000000
--- a/cpp/src/arrow/vendored/variant/variant_io.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Vendored from https://github.com/mapbox/variant at tag v1.1.5
-
-#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
-#define MAPBOX_UTIL_VARIANT_IO_HPP
-
-#include <iosfwd>
-
-#include "variant.hpp"
-
-namespace mapbox {
-namespace util {
-
-namespace detail {
-// operator<< helper
-template <typename Out>
-class printer
-{
-public:
- explicit printer(Out& out)
- : out_(out) {}
- printer& operator=(printer const&) = delete;
-
- // visitor
- template <typename T>
- void operator()(T const& operand) const
- {
- out_ << operand;
- }
-
-private:
- Out& out_;
-};
-}
-
-// operator<<
-template <typename CharT, typename Traits, typename... Types>
-VARIANT_INLINE std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& out, variant<Types...> const& rhs)
-{
- detail::printer<std::basic_ostream<CharT, Traits>> visitor(out);
- apply_visitor(visitor, rhs);
- return out;
-}
-} // namespace util
-} // namespace mapbox
-
-#endif // MAPBOX_UTIL_VARIANT_IO_HPP
diff --git a/cpp/src/arrow/vendored/variant/variant_visitor.hpp b/cpp/src/arrow/vendored/variant/variant_visitor.hpp
deleted file mode 100644
index 60020f4..0000000
--- a/cpp/src/arrow/vendored/variant/variant_visitor.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Vendored from https://github.com/mapbox/variant at tag v1.1.5
-
-#ifndef MAPBOX_UTIL_VARIANT_VISITOR_HPP
-#define MAPBOX_UTIL_VARIANT_VISITOR_HPP
-
-namespace mapbox {
-namespace util {
-
-template <typename... Fns>
-struct visitor;
-
-template <typename Fn>
-struct visitor<Fn> : Fn
-{
- using type = Fn;
- using Fn::operator();
-
- visitor(Fn fn) : Fn(fn) {}
-};
-
-template <typename Fn, typename... Fns>
-struct visitor<Fn, Fns...> : Fn, visitor<Fns...>
-{
- using type = visitor;
- using Fn::operator();
- using visitor<Fns...>::operator();
-
- visitor(Fn fn, Fns... fns) : Fn(fn), visitor<Fns...>(fns...) {}
-};
-
-template <typename... Fns>
-visitor<Fns...> make_visitor(Fns... fns)
-{
- return visitor<Fns...>(fns...);
-}
-
-} // namespace util
-} // namespace mapbox
-
-#endif // MAPBOX_UTIL_VARIANT_VISITOR_HPP
diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index 02f2e70..22916fd 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -69,6 +69,7 @@ set(SRC_FILES
llvm_generator.cc
llvm_types.cc
like_holder.cc
+ literal_holder.cc
projector.cc
regex_util.cc
selection_vector.cc
diff --git a/cpp/src/gandiva/expr_validator.cc b/cpp/src/gandiva/expr_validator.cc
index 43de9d7..bc532bd 100644
--- a/cpp/src/gandiva/expr_validator.cc
+++ b/cpp/src/gandiva/expr_validator.cc
@@ -107,7 +107,7 @@ Status ExprValidator::Visit(const IfNode& node) {
Status ExprValidator::Visit(const LiteralNode& node) {
auto llvm_type = types_->IRType(node.return_type()->id());
ARROW_RETURN_IF(llvm_type == nullptr,
- Status::ExpressionValidationError("Value ", node.holder(),
+ Status::ExpressionValidationError("Value ", ToString(node.holder()),
" has unsupported data type ",
node.return_type()->name()));
diff --git a/cpp/src/gandiva/like_holder.cc b/cpp/src/gandiva/like_holder.cc
index f4bbc51..404105b 100644
--- a/cpp/src/gandiva/like_holder.cc
+++ b/cpp/src/gandiva/like_holder.cc
@@ -73,7 +73,7 @@ Status LikeHolder::Make(const FunctionNode& node, std::shared_ptr<LikeHolder>* h
Status::Invalid(
"'like' function requires a string literal as the second parameter"));
- return Make(literal->holder().get<std::string>(), holder);
+ return Make(arrow::util::get<std::string>(literal->holder()), holder);
}
Status LikeHolder::Make(const std::string& sql_pattern,
diff --git a/cpp/src/gandiva/literal_holder.h b/cpp/src/gandiva/literal_holder.cc
similarity index 66%
copy from cpp/src/gandiva/literal_holder.h
copy to cpp/src/gandiva/literal_holder.cc
index 36afdd3..beed811 100644
--- a/cpp/src/gandiva/literal_holder.h
+++ b/cpp/src/gandiva/literal_holder.cc
@@ -15,21 +15,31 @@
// specific language governing permissions and limitations
// under the License.
-#ifndef GANDIVA_LITERAL_HOLDER
-#define GANDIVA_LITERAL_HOLDER
+#include <sstream>
-#include <string>
+#include "gandiva/literal_holder.h"
-#include <arrow/util/variant.h>
+namespace gandiva {
-#include <arrow/type.h>
-#include "gandiva/decimal_scalar.h"
+namespace {
-namespace gandiva {
+template <typename OStream>
+struct LiteralToStream {
+ OStream& ostream_;
-using LiteralHolder =
- arrow::util::variant<bool, float, double, int8_t, int16_t, int32_t, int64_t, uint8_t,
- uint16_t, uint32_t, uint64_t, std::string, DecimalScalar128>;
-} // namespace gandiva
+ template <typename Value>
+ void operator()(const Value& v) {
+ ostream_ << v;
+ }
+};
-#endif // GANDIVA_LITERAL_HOLDER
+} // namespace
+
+std::string ToString(const LiteralHolder& holder) {
+ std::stringstream ss;
+ LiteralToStream<std::stringstream> visitor{ss};
+ ::arrow::util::visit(visitor, holder);
+ return ss.str();
+}
+
+} // namespace gandiva
diff --git a/cpp/src/gandiva/literal_holder.h b/cpp/src/gandiva/literal_holder.h
index 36afdd3..e37e283 100644
--- a/cpp/src/gandiva/literal_holder.h
+++ b/cpp/src/gandiva/literal_holder.h
@@ -30,6 +30,9 @@ namespace gandiva {
using LiteralHolder =
arrow::util::variant<bool, float, double, int8_t, int16_t, int32_t, int64_t, uint8_t,
uint16_t, uint32_t, uint64_t, std::string, DecimalScalar128>;
+
+std::string ToString(const LiteralHolder& holder);
+
} // namespace gandiva
#endif // GANDIVA_LITERAL_HOLDER
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index 10f160d..28887c9 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -587,52 +587,52 @@ void LLVMGenerator::Visitor::Visit(const LiteralDex& dex) {
switch (dex.type()->id()) {
case arrow::Type::BOOL:
- value = types->i1_constant(dex.holder().get<bool>());
+ value = types->i1_constant(arrow::util::get<bool>(dex.holder()));
break;
case arrow::Type::UINT8:
- value = types->i8_constant(dex.holder().get<uint8_t>());
+ value = types->i8_constant(arrow::util::get<uint8_t>(dex.holder()));
break;
case arrow::Type::UINT16:
- value = types->i16_constant(dex.holder().get<uint16_t>());
+ value = types->i16_constant(arrow::util::get<uint16_t>(dex.holder()));
break;
case arrow::Type::UINT32:
- value = types->i32_constant(dex.holder().get<uint32_t>());
+ value = types->i32_constant(arrow::util::get<uint32_t>(dex.holder()));
break;
case arrow::Type::UINT64:
- value = types->i64_constant(dex.holder().get<uint64_t>());
+ value = types->i64_constant(arrow::util::get<uint64_t>(dex.holder()));
break;
case arrow::Type::INT8:
- value = types->i8_constant(dex.holder().get<int8_t>());
+ value = types->i8_constant(arrow::util::get<int8_t>(dex.holder()));
break;
case arrow::Type::INT16:
- value = types->i16_constant(dex.holder().get<int16_t>());
+ value = types->i16_constant(arrow::util::get<int16_t>(dex.holder()));
break;
case arrow::Type::INT32:
- value = types->i32_constant(dex.holder().get<int32_t>());
+ value = types->i32_constant(arrow::util::get<int32_t>(dex.holder()));
break;
case arrow::Type::INT64:
- value = types->i64_constant(dex.holder().get<int64_t>());
+ value = types->i64_constant(arrow::util::get<int64_t>(dex.holder()));
break;
case arrow::Type::FLOAT:
- value = types->float_constant(dex.holder().get<float>());
+ value = types->float_constant(arrow::util::get<float>(dex.holder()));
break;
case arrow::Type::DOUBLE:
- value = types->double_constant(dex.holder().get<double>());
+ value = types->double_constant(arrow::util::get<double>(dex.holder()));
break;
case arrow::Type::STRING:
case arrow::Type::BINARY: {
- const std::string& str = dex.holder().get<std::string>();
+ const std::string& str = arrow::util::get<std::string>(dex.holder());
llvm::Constant* str_int_cast = types->i64_constant((int64_t)str.c_str());
value = llvm::ConstantExpr::getIntToPtr(str_int_cast, types->i8_ptr_type());
@@ -641,24 +641,24 @@ void LLVMGenerator::Visitor::Visit(const LiteralDex& dex) {
}
case arrow::Type::DATE64:
- value = types->i64_constant(dex.holder().get<int64_t>());
+ value = types->i64_constant(arrow::util::get<int64_t>(dex.holder()));
break;
case arrow::Type::TIME32:
- value = types->i32_constant(dex.holder().get<int32_t>());
+ value = types->i32_constant(arrow::util::get<int32_t>(dex.holder()));
break;
case arrow::Type::TIME64:
- value = types->i64_constant(dex.holder().get<int64_t>());
+ value = types->i64_constant(arrow::util::get<int64_t>(dex.holder()));
break;
case arrow::Type::TIMESTAMP:
- value = types->i64_constant(dex.holder().get<int64_t>());
+ value = types->i64_constant(arrow::util::get<int64_t>(dex.holder()));
break;
case arrow::Type::DECIMAL: {
// build code for struct
- auto scalar = dex.holder().get<DecimalScalar128>();
+ auto scalar = arrow::util::get<DecimalScalar128>(dex.holder());
// ConstantInt doesn't have a get method that takes int128 or a pair of int64. so,
// passing the string representation instead.
auto int128_value =
diff --git a/cpp/src/gandiva/node.h b/cpp/src/gandiva/node.h
index ca51123..87f87e9 100644
--- a/cpp/src/gandiva/node.h
+++ b/cpp/src/gandiva/node.h
@@ -73,16 +73,16 @@ class GANDIVA_EXPORT LiteralNode : public Node {
return ss.str();
}
- ss << holder();
+ ss << gandiva::ToString(holder_);
// The default formatter prints in decimal can cause a loss in precision. so,
// print in hex. Can't use hexfloat since gcc 4.9 doesn't support it.
if (return_type()->id() == arrow::Type::DOUBLE) {
- double dvalue = holder_.get<double>();
+ double dvalue = arrow::util::get<double>(holder_);
uint64_t bits;
memcpy(&bits, &dvalue, sizeof(bits));
ss << " raw(" << std::hex << bits << ")";
} else if (return_type()->id() == arrow::Type::FLOAT) {
- float fvalue = holder_.get<float>();
+ float fvalue = arrow::util::get<float>(holder_);
uint32_t bits;
memcpy(&bits, &fvalue, sizeof(bits));
ss << " raw(" << std::hex << bits << ")";
diff --git a/cpp/src/gandiva/to_date_holder.cc b/cpp/src/gandiva/to_date_holder.cc
index 824654f..ca93881 100644
--- a/cpp/src/gandiva/to_date_holder.cc
+++ b/cpp/src/gandiva/to_date_holder.cc
@@ -44,7 +44,7 @@ Status ToDateHolder::Make(const FunctionNode& node,
return Status::Invalid(
"'to_date' function requires a string literal as the second parameter");
}
- auto pattern = literal_pattern->holder().get<std::string>();
+ auto pattern = arrow::util::get<std::string>(literal_pattern->holder());
auto literal_suppress_errors = dynamic_cast<LiteralNode*>(node.children().at(2).get());
if (literal_pattern == nullptr) {
@@ -57,7 +57,7 @@ Status ToDateHolder::Make(const FunctionNode& node,
return Status::Invalid(
"'to_date' function requires a int literal as the third parameter");
}
- auto suppress_errors = literal_suppress_errors->holder().get<int>();
+ auto suppress_errors = arrow::util::get<int>(literal_suppress_errors->holder());
return Make(pattern, suppress_errors, holder);
}