early-access version 3088

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/apply_visitor_binary.hpp

@@ -0,0 +1,358 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_binary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman
+// Copyright (c) 2014-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+
+#include <boost/config.hpp>
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#   include <boost/variant/detail/has_result_type.hpp>
+#endif
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#   include <boost/core/enable_if.hpp>
+#   include <boost/type_traits/is_lvalue_reference.hpp>
+#   include <boost/type_traits/is_same.hpp>
+#   include <boost/move/utility_core.hpp> // for boost::move, boost::forward
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable1, visitable2)
+//
+// Visits visitable1 and visitable2 such that their values (which we
+// shall call x and y, respectively) are used as arguments in the
+// expression visitor(x, y).
+//
+
+namespace detail { namespace variant {
+
+template <typename Visitor, typename Value1, bool MoveSemantics>
+class apply_visitor_binary_invoke
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Value1& value1_;
+
+public: // structors
+
+    apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+
+public: // visitor interfaces
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    template <typename Value2>
+        typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
+    operator()(Value2&& value2)
+    {
+        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
+    }
+
+    template <typename Value2>
+        typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
+    operator()(Value2&& value2)
+    {
+        return visitor_(value1_, ::boost::forward<Value2>(value2));
+    }
+
+#else
+
+    template <typename Value2>
+        result_type
+    operator()(Value2& value2)
+    {
+        return visitor_(value1_, value2);
+    }
+
+#endif
+
+private:
+    apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
+};
+
+template <typename Visitor, typename Visitable2, bool MoveSemantics>
+class apply_visitor_binary_unwrap
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+
+public: // structors
+
+    apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+
+public: // visitor interfaces
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    template <typename Value1>
+        typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
+    operator()(Value1&& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
+    }
+
+    template <typename Value1>
+        typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
+    operator()(Value1&& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+#else
+
+    template <typename Value1>
+        result_type
+    operator()(Value1& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            , false
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+#endif
+
+private:
+    apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);
+
+};
+
+}} // namespace detail::variant
+
+//
+// nonconst-visitor version:
+//
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline typename Visitor::result_type
+apply_visitor( Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+#else
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline typename Visitor::result_type
+apply_visitor( Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2, false
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#endif
+
+//
+// const-visitor version:
+//
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline typename Visitor::result_type
+apply_visitor( const Visitor& visitor , Visitable1&& visitable1 , Visitable2&& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+#else
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline typename Visitor::result_type
+apply_visitor( const Visitor& visitor , Visitable1& visitable1 , Visitable2& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2, false
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#endif
+
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable1, visitable2)
+//
+// C++14 part.
+//
+
+namespace detail { namespace variant {
+
+template <typename Visitor, typename Value1, bool MoveSemantics>
+class apply_visitor_binary_invoke_cpp14
+{
+    Visitor& visitor_;
+    Value1& value1_;
+
+public: // structors
+
+    apply_visitor_binary_invoke_cpp14(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value2>
+    decltype(auto) operator()(Value2&& value2, typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, bool>::type = true)
+    {
+        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
+    }
+
+    template <typename Value2>
+    decltype(auto) operator()(Value2&& value2, typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, bool>::type = true)
+    {
+        return visitor_(value1_, ::boost::forward<Value2>(value2));
+    }
+
+private:
+    apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&);
+};
+
+template <typename Visitor, typename Visitable2, bool MoveSemantics>
+class apply_visitor_binary_unwrap_cpp14
+{
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+
+public: // structors
+
+    apply_visitor_binary_unwrap_cpp14(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value1>
+    decltype(auto) operator()(Value1&& value1, typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, bool>::type = true)
+    {
+        apply_visitor_binary_invoke_cpp14<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
+    }
+
+    template <typename Value1>
+    decltype(auto) operator()(Value1&& value1, typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, bool>::type = true)
+    {
+        apply_visitor_binary_invoke_cpp14<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+private:
+    apply_visitor_binary_unwrap_cpp14& operator=(const apply_visitor_binary_unwrap_cpp14&);
+};
+
+}} // namespace detail::variant
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        bool
+    >::type = true)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
+          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        bool
+    >::type = true)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
+          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/apply_visitor_delayed.hpp

@@ -0,0 +1,146 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_delayed.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+
+#include <boost/variant/detail/has_result_type.hpp>
+#include <boost/core/enable_if.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor)
+//
+// Returns a function object, overloaded for unary and binary usage, that
+// visits its arguments using visitor (or a copy of visitor) via
+//  * apply_visitor( visitor, [argument] )
+// under unary invocation, or
+//  * apply_visitor( visitor, [argument1], [argument2] )
+// under binary invocation.
+//
+// NOTE: Unlike other apply_visitor forms, the visitor object must be
+//   non-const; this prevents user from giving temporary, to disastrous
+//   effect (i.e., returned function object would have dead reference).
+//
+
+template <typename Visitor>
+class apply_visitor_delayed_t
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+
+public: // structors
+
+    explicit apply_visitor_delayed_t(Visitor& visitor) BOOST_NOEXCEPT
+      : visitor_(visitor)
+    {
+    }
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+public: // N-ary visitor interface
+    template <typename... Visitables>
+    result_type operator()(Visitables&... visitables) const
+    {
+        return apply_visitor(visitor_, visitables...);
+    }
+
+#else // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+public: // unary visitor interface
+
+    template <typename Visitable>
+    result_type operator()(Visitable& visitable) const
+    {
+        return apply_visitor(visitor_, visitable);
+    }
+
+public: // binary visitor interface
+
+    template <typename Visitable1, typename Visitable2>
+    result_type operator()(Visitable1& visitable1, Visitable2& visitable2) const
+    {
+        return apply_visitor(visitor_, visitable1, visitable2);
+    }
+
+#endif // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+private:
+    apply_visitor_delayed_t& operator=(const apply_visitor_delayed_t&);
+
+};
+
+template <typename Visitor>
+inline typename boost::enable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        apply_visitor_delayed_t<Visitor>
+    >::type apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_t<Visitor>(visitor);
+}
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) \
+    && !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template <typename Visitor>
+class apply_visitor_delayed_cpp14_t
+{
+private: // representation
+    Visitor& visitor_;
+
+public: // structors
+
+    explicit apply_visitor_delayed_cpp14_t(Visitor& visitor) BOOST_NOEXCEPT
+      : visitor_(visitor)
+    {
+    }
+
+public: // N-ary visitor interface
+    template <typename... Visitables>
+    decltype(auto) operator()(Visitables&... visitables) const
+    {
+        return apply_visitor(visitor_, visitables...);
+    }
+
+private:
+    apply_visitor_delayed_cpp14_t& operator=(const apply_visitor_delayed_cpp14_t&);
+
+};
+
+template <typename Visitor>
+inline  typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        apply_visitor_delayed_cpp14_t<Visitor>
+    >::type apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_cpp14_t<Visitor>(visitor);
+}
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+            // && !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/apply_visitor_unary.hpp

@@ -0,0 +1,145 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_unary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman
+// Copyright (c) 2014-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+
+#include <boost/config.hpp>
+#include <boost/move/utility.hpp>
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#   include <boost/mpl/distance.hpp>
+#   include <boost/mpl/advance.hpp>
+#   include <boost/mpl/deref.hpp>
+#   include <boost/mpl/size.hpp>
+#   include <boost/utility/declval.hpp>
+#   include <boost/core/enable_if.hpp>
+#   include <boost/type_traits/copy_cv_ref.hpp>
+#   include <boost/type_traits/remove_reference.hpp>
+#   include <boost/variant/detail/has_result_type.hpp>
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable)
+//
+// Visits visitable with visitor.
+//
+
+//
+// nonconst-visitor version:
+//
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename Visitor, typename Visitable>
+inline typename Visitor::result_type
+apply_visitor(Visitor& visitor, Visitable&& visitable)
+{
+    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
+}
+#else
+template <typename Visitor, typename Visitable>
+inline typename Visitor::result_type
+apply_visitor(Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+#endif
+
+//
+// const-visitor version:
+//
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename Visitor, typename Visitable>
+inline typename Visitor::result_type
+apply_visitor(const Visitor& visitor, Visitable&& visitable)
+{
+    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
+}
+#else
+template <typename Visitor, typename Visitable>
+inline typename Visitor::result_type
+apply_visitor(const Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+#endif
+
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#define BOOST_VARIANT_HAS_DECLTYPE_APPLY_VISITOR_RETURN_TYPE
+
+// C++14
+namespace detail { namespace variant {
+
+// This class serves only metaprogramming purposes. none of its methods must be called at runtime!
+template <class Visitor, class Variant>
+struct result_multideduce1 {
+    typedef typename remove_reference<Variant>::type::types types;
+    typedef typename boost::mpl::begin<types>::type begin_it;
+    typedef typename boost::mpl::advance<
+        begin_it, boost::mpl::int_<boost::mpl::size<types>::type::value - 1>
+    >::type                                         last_it;
+
+    template <class It, class Dummy = void> // avoid explicit specialization in class scope
+    struct deduce_impl {
+        typedef typename boost::mpl::next<It>::type next_t;
+        typedef typename boost::mpl::deref<It>::type value_t;
+        typedef decltype(true ? boost::declval< Visitor& >()( boost::declval< copy_cv_ref_t< value_t, Variant > >() )
+                              : boost::declval< typename deduce_impl<next_t>::type >()) type;
+    };
+
+    template <class Dummy>
+    struct deduce_impl<last_it, Dummy> {
+        typedef typename boost::mpl::deref<last_it>::type value_t;
+        typedef decltype(boost::declval< Visitor& >()( boost::declval< copy_cv_ref_t< value_t, Variant > >() )) type;
+    };
+
+    typedef typename deduce_impl<begin_it>::type type;
+};
+
+template <class Visitor, class Variant>
+struct result_wrapper1
+{
+    typedef typename result_multideduce1<Visitor, Variant>::type result_type;
+
+    Visitor&& visitor_;
+    explicit result_wrapper1(Visitor&& visitor) BOOST_NOEXCEPT
+        : visitor_(::boost::forward<Visitor>(visitor))
+    {}
+
+    template <class T>
+    result_type operator()(T&& val) const {
+        return visitor_(::boost::forward<T>(val));
+    }
+};
+
+}} // namespace detail::variant
+
+template <typename Visitor, typename Visitable>
+inline decltype(auto) apply_visitor(Visitor&& visitor, Visitable&& visitable,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        bool
+    >::type = true)
+{
+    boost::detail::variant::result_wrapper1<Visitor, Visitable> cpp14_vis(::boost::forward<Visitor>(visitor));
+    return ::boost::forward<Visitable>(visitable).apply_visitor(cpp14_vis);
+}
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/backup_holder.hpp

@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/backup_holder.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+#define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+template <typename T>
+class backup_holder
+{
+private: // representation
+
+    T* backup_;
+
+public: // structors
+
+    ~backup_holder() BOOST_NOEXCEPT
+    {
+        delete backup_;
+    }
+
+    explicit backup_holder(T* backup) BOOST_NOEXCEPT
+        : backup_(backup)
+    {
+    }
+
+    backup_holder(const backup_holder&);
+
+public: // modifiers
+
+    backup_holder& operator=(const backup_holder& rhs)
+    {
+        *backup_ = rhs.get();
+        return *this;
+    }
+
+    backup_holder& operator=(const T& rhs)
+    {
+        *backup_ = rhs;
+        return *this;
+    }
+
+    void swap(backup_holder& rhs) BOOST_NOEXCEPT
+    {
+        T* tmp = rhs.backup_;
+        rhs.backup_ = this->backup_;
+        this->backup_ = tmp;
+    }
+
+public: // queries
+
+    T& get() BOOST_NOEXCEPT
+    {
+        return *backup_;
+    }
+
+    const T& get() const BOOST_NOEXCEPT
+    {
+        return *backup_;
+    }
+
+};
+
+template <typename T>
+backup_holder<T>::backup_holder(const backup_holder&)
+    : backup_(0)
+{
+    // not intended for copy, but do not want to prohibit syntactically
+    BOOST_ASSERT(false);
+}
+
+template <typename T>
+void swap(backup_holder<T>& lhs, backup_holder<T>& rhs) BOOST_NOEXCEPT
+{
+    lhs.swap(rhs);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/cast_storage.hpp

@@ -0,0 +1,42 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/cast_storage.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
+#define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template cast_storage
+//
+// Casts the given storage to the specified type, but with qualification.
+//
+
+template <typename T>
+inline T& cast_storage(void* storage)
+{
+    return *static_cast<T*>(storage);
+}
+
+template <typename T>
+inline const T& cast_storage(const void* storage)
+{
+    return *static_cast<const T*>(storage);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/config.hpp

@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/config.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2016-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_CONFIG_HPP
+#define BOOST_VARIANT_DETAIL_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#endif // BOOST_VARIANT_DETAIL_CONFIG_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/element_index.hpp

@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/element_index.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2014-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
+#define BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
+
+#include <boost/config.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/find_if.hpp>
+
+namespace boost { namespace detail { namespace variant {
+
+template <class VariantElement, class T>
+struct variant_element_functor :
+    boost::mpl::or_<
+        boost::is_same<VariantElement, T>,
+        boost::is_same<VariantElement, boost::recursive_wrapper<T> >,
+        boost::is_same<VariantElement, T& >
+    >
+{};
+
+template <class Types, class T>
+struct element_iterator_impl :
+    boost::mpl::find_if<
+        Types,
+        boost::mpl::or_<
+            variant_element_functor<boost::mpl::_1, T>,
+            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >
+        >
+    >
+{};
+
+template <class Variant, class T>
+struct element_iterator :
+    element_iterator_impl< typename Variant::types, typename boost::remove_reference<T>::type >
+{};
+
+template <class Variant, class T>
+struct holds_element :
+    boost::mpl::not_<
+        boost::is_same<
+            typename boost::mpl::end<typename Variant::types>::type,
+            typename element_iterator<Variant, T>::type
+        >
+    >
+{};
+
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/enable_recursive.hpp

@@ -0,0 +1,133 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+
+#include <boost/variant/detail/enable_recursive_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   include <boost/mpl/apply.hpp>
+#   include <boost/mpl/eval_if.hpp>
+#   include <boost/mpl/lambda.hpp>
+#endif
+
+#include <boost/variant/detail/substitute.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/variant/recursive_wrapper.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    substitute< T , Dest , Source > \
+    /**/
+
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template rebind1
+//
+// Limited workaround in case 'substitute' metafunction unavailable.
+//
+
+template <typename T, typename U1>
+struct rebind1
+{
+private:
+    typedef typename mpl::lambda<
+          mpl::identity<T>
+        >::type le_;
+
+public:
+    typedef typename mpl::eval_if<
+          is_same< le_, mpl::identity<T> >
+        , le_ // identity<T>
+        , mpl::apply1<le_, U1>
+        >::type type;
+};
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    rebind1< T , Dest > \
+    /**/
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// See boost/variant/detail/enable_recursive_fwd.hpp for more information.
+//
+
+
+template <typename T, typename RecursiveVariant, typename NoWrapper>
+struct enable_recursive
+    : BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )
+{
+};
+
+template <typename T, typename RecursiveVariant>
+struct enable_recursive< T,RecursiveVariant,mpl::false_ >
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )::type t_;
+
+public: // metafunction result
+
+    // [Wrap with recursive_wrapper only if rebind really changed something:]
+    typedef typename mpl::if_<
+          mpl::or_<
+              is_same< t_,T >
+            , is_reference<t_>
+            , is_pointer<t_>
+            >
+        , t_
+        , boost::recursive_wrapper<t_>
+        >::type type;
+
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <typename RecursiveVariant, typename NoWrapper>
+struct quoted_enable_recursive
+{
+    template <typename T>
+    struct apply
+        : enable_recursive<T, RecursiveVariant, NoWrapper>
+    {
+    };
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/enable_recursive_fwd.hpp

@@ -0,0 +1,87 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#include <boost/mpl/bool_fwd.hpp>
+
+#   include <boost/mpl/bool.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) tag recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+
+template <typename T>
+struct recursive_flag
+{
+    typedef T type;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+
+template <typename T>
+struct is_recursive_flag
+    : mpl::false_
+{
+};
+
+template <typename T>
+struct is_recursive_flag< recursive_flag<T> >
+    : mpl::true_
+{
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// Attempts recursive_variant_ tag substitution, wrapping with
+// boost::recursive_wrapper if substituion occurs w/ non-indirect result
+// (i.e., not a reference or pointer) *and* NoWrapper is false_.
+//
+template <
+      typename T
+    , typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct enable_recursive;
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <
+      typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct quoted_enable_recursive;
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/forced_return.hpp

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/forced_return.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2015-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
+#define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+
+
+#ifdef BOOST_MSVC
+# pragma warning( push )
+# pragma warning( disable : 4702 ) // unreachable code
+#endif
+
+namespace boost { namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template forced_return
+//
+// Logical error to permit invocation at runtime, but (artificially) satisfies
+// compile-time requirement of returning a result value.
+//
+template <typename T>
+BOOST_NORETURN inline T
+forced_return()
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    T (*dummy)() = 0;
+    (void)dummy;
+    BOOST_UNREACHABLE_RETURN(dummy());
+}
+
+}}} // namespace boost::detail::variant
+
+
+#ifdef BOOST_MSVC
+# pragma warning( pop )
+#endif
+
+#endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/has_result_type.hpp

@@ -0,0 +1,37 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/has_result_type.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2014-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+#define BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost { namespace detail { namespace variant {
+
+template <typename T >
+struct has_result_type {
+private:
+    typedef char                      yes;
+    typedef struct { char array[2]; } no;
+
+    template<typename C> static yes test(typename boost::remove_reference<typename C::result_type>::type*);
+    template<typename C> static no  test(...);
+
+public:
+    BOOST_STATIC_CONSTANT(bool, value = sizeof(test<T>(0)) == sizeof(yes));
+};
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/hash_variant.hpp

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/hash_variant.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2011-2022 Antony Polukhin
+//
+// 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)
+
+
+#ifndef BOOST_HASH_VARIANT_FUNCTION_HPP
+#define BOOST_HASH_VARIANT_FUNCTION_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost {
+
+    namespace detail { namespace variant {
+        struct variant_hasher: public boost::static_visitor<std::size_t> {
+            template <class T>
+            std::size_t operator()(T const& val) const {
+                boost::hash<T> hasher;
+                return hasher(val);
+            }
+        };
+    }}
+
+    template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+    std::size_t hash_value(variant< BOOST_VARIANT_ENUM_PARAMS(T) > const& val) {
+        std::size_t seed = boost::apply_visitor(detail::variant::variant_hasher(), val);
+        hash_combine(seed, val.which());
+        return seed;
+    }
+}
+
+#endif
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/initializer.hpp

@@ -0,0 +1,249 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/initializer.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_INITIALIZER_HPP
+#define BOOST_VARIANT_DETAIL_INITIALIZER_HPP
+
+#include <new> // for placement new
+
+#include <boost/config.hpp>
+
+#include <boost/call_traits.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/detail/move.hpp>
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#   include <boost/mpl/int.hpp>
+#   include <boost/mpl/iter_fold.hpp>
+#   include <boost/mpl/next.hpp>
+#   include <boost/mpl/deref.hpp>
+#   include <boost/mpl/pair.hpp>
+#   include <boost/mpl/protect.hpp>
+#else
+#   include <boost/variant/variant_fwd.hpp>
+#   include <boost/preprocessor/cat.hpp>
+#   include <boost/preprocessor/enum.hpp>
+#   include <boost/preprocessor/repeat.hpp>
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) support to simulate standard overload resolution rules
+//
+// The below initializers allows variant to follow standard overload
+// resolution rules over the specified set of bounded types.
+//
+// On compilers where using declarations in class templates can correctly
+// avoid name hiding, use an optimal solution based on the variant's typelist.
+//
+// Otherwise, use a preprocessor workaround based on knowledge of the fixed
+// size of the variant's psuedo-variadic template parameter list.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+// (detail) quoted metafunction make_initializer_node
+//
+// Exposes a pair whose first type is a node in the initializer hierarchy.
+//
+struct make_initializer_node
+{
+    template <typename BaseIndexPair, typename Iterator>
+    struct apply
+    {
+    private: // helpers, for metafunction result (below)
+
+        typedef typename BaseIndexPair::first
+            base;
+        typedef typename BaseIndexPair::second
+            index;
+
+        class initializer_node
+            : public base
+        {
+        private: // helpers, for static functions (below)
+
+            typedef typename mpl::deref<Iterator>::type
+                recursive_enabled_T;
+            typedef typename unwrap_recursive<recursive_enabled_T>::type
+                public_T;
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+            typedef boost::is_reference<public_T> 
+                is_reference_content_t;
+
+            typedef typename boost::mpl::if_<is_reference_content_t, public_T, const public_T& >::type 
+                param_T;
+
+            template <class T> struct disable_overload{};
+
+            typedef typename boost::mpl::if_<is_reference_content_t, disable_overload<public_T>, public_T&& >::type 
+                param2_T;
+#else
+            typedef typename call_traits<public_T>::param_type
+                param_T;
+#endif
+
+        public: // static functions
+
+            using base::initialize;
+
+            static int initialize(void* dest, param_T operand)
+            {
+                typedef typename boost::detail::make_reference_content<
+                      recursive_enabled_T
+                    >::type internal_T;
+
+                new(dest) internal_T(operand);
+                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
+            }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+            static int initialize(void* dest, param2_T operand)
+            {
+                // This assert must newer trigger, because all the reference contents are
+                // handled by the initilize(void* dest, param_T operand) function above
+                BOOST_ASSERT(!is_reference_content_t::value);
+
+                typedef typename boost::mpl::if_<is_reference_content_t, param2_T, recursive_enabled_T>::type value_T;
+                new(dest) value_T( boost::detail::variant::move(operand) );
+                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
+            }
+#endif
+        };
+
+        friend class initializer_node;
+
+    public: // metafunction result
+
+        typedef mpl::pair<
+              initializer_node
+            , typename mpl::next< index >::type
+            > type;
+
+    };
+};
+
+// (detail) class initializer_root
+//
+// Every level of the initializer hierarchy must expose the name
+// "initialize," so initializer_root provides a dummy function:
+//
+class initializer_root
+{
+public: // static functions
+
+    static void initialize();
+
+};
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+    /**/
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+    /**/
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) >
+struct preprocessor_list_initializer
+{
+public: // static functions
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+        static int initialize( \
+              void* dest \
+            , BOOST_PP_CAT(param_T,N) operand \
+            ) \
+        { \
+            typedef typename boost::detail::make_reference_content< \
+                  BOOST_PP_CAT(recursive_enabled_T,N) \
+                >::type internal_T; \
+            \
+            new(dest) internal_T(operand); \
+            return (N); /*which*/ \
+        } \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+
+};
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_INITIALIZER_T
+//
+// Given both the variant's typelist and a basename for forming the list of
+// bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer
+// most appropriate to the current compiler.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::mpl::iter_fold< \
+          mpl_seq \
+        , ::boost::mpl::pair< \
+              ::boost::detail::variant::initializer_root \
+            , ::boost::mpl::int_<0> \
+            > \
+        , ::boost::mpl::protect< \
+              ::boost::detail::variant::make_initializer_node \
+            > \
+        >::type::first \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        /**/
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::detail::variant::preprocessor_list_initializer< \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        > \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/make_variant_list.hpp

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/make_variant_list.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman, Itay Maman
+// Copyright (c) 2013-2022 Antony Polukhin
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+#define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/mpl/list.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_variant_list
+//
+// Provides a MPL-compatible sequence with the specified non-void types
+// as arguments.
+//
+// Rationale: see class template convert_void (variant_fwd.hpp) and using-
+// declaration workaround (below).
+//
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template < typename... T >
+struct make_variant_list
+{
+    typedef typename mpl::list< T... >::type type;
+};
+
+#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_variant_list
+{
+public: // metafunction result
+
+    // [Define a macro to convert any void(NN) tags to mpl::void...]
+#   define BOOST_VARIANT_AUX_CONVERT_VOID(z, N,_)  \
+        typename convert_void< BOOST_PP_CAT(T,N) >::type
+
+    // [...so that the specified types can be passed to mpl::list...]
+    typedef typename mpl::list< 
+          BOOST_PP_ENUM(
+              BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_VARIANT_AUX_CONVERT_VOID
+            , _
+            )
+        >::type type;
+
+    // [...and, finally, the conversion macro can be undefined:]
+#   undef BOOST_VARIANT_AUX_CONVERT_VOID
+
+};
+
+#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/move.hpp

@@ -0,0 +1,50 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/move.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+//  Copyright (c) 2002-2003 Eric Friedman
+//  Copyright (c) 2002 by Andrei Alexandrescu
+//  Copyright (c) 2013-2022 Antony Polukhin
+//
+//  Use, modification and distribution are subject to 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)
+//
+//  This file derivative of MoJO. Much thanks to Andrei for his initial work.
+//  See <http://www.cuj.com/experts/2102/alexandr.htm> for information on MOJO.
+//  Re-issued here under the Boost Software License, with permission of the original
+//  author (Andrei Alexandrescu).
+
+
+#ifndef BOOST_VARIANT_DETAIL_MOVE_HPP
+#define BOOST_VARIANT_DETAIL_MOVE_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/move/utility_core.hpp> // for boost::move
+#include <boost/move/adl_move_swap.hpp>
+
+namespace boost { namespace detail { namespace variant {
+
+using boost::move;
+
+//////////////////////////////////////////////////////////////////////////
+// function template move_swap
+//
+// Swaps using Koenig lookup but falls back to move-swap for primitive
+// types and on non-conforming compilers.
+//
+
+template <typename T>
+inline void move_swap(T& lhs, T& rhs)
+{
+    ::boost::adl_move_swap(lhs, rhs);
+}
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_MOVE_HPP
+
+
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/multivisitors_cpp11_based.hpp

@@ -0,0 +1,217 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via variadic templates and std::tuple
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-2014.
+//
+//  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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#include <boost/move/utility.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/core/enable_if.hpp>
+
+#if defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   error "This file requires <tuple> and variadic templates support"
+#endif
+
+#include <tuple>
+
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    // Implementing some of the C++14 features in C++11
+    template <std::size_t... I> class index_sequence {};
+
+    template <std::size_t N, std::size_t... I> 
+    struct make_index_sequence 
+        : make_index_sequence<N-1, N-1, I...> 
+    {};
+    template <std::size_t... I> 
+    struct make_index_sequence<0, I...> 
+        : index_sequence<I...> 
+    {};
+
+    template <typename T_, bool MoveSemantics_>
+    struct MoveableWrapper //Just a reference with some metadata
+    {
+        typedef T_ T;
+        static constexpr bool MoveSemantics = MoveSemantics_;
+
+        T& v;
+    };
+
+    template <typename Tp, bool MoveSemantics>
+    MoveableWrapper<Tp, MoveSemantics>
+        wrap(Tp& t)
+    {
+        return MoveableWrapper<Tp, MoveSemantics>{t};
+    }
+
+    template <typename Wrapper>
+    typename enable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type
+        unwrap(Wrapper& w)
+    {
+        return ::boost::move(w.v);
+    }
+
+    template <typename Wrapper>
+    typename disable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type &
+        unwrap(Wrapper& w)
+    {
+        return w.v;
+    }
+
+    // Implementing some of the helper tuple methods
+    template <std::size_t... I, typename Tuple>
+    std::tuple<typename std::tuple_element<I + 1, Tuple>::type...> 
+        tuple_tail_impl(const Tuple& tpl, index_sequence<I...>)
+    {
+        return std::tuple<
+            typename std::tuple_element<I + 1, Tuple>::type...
+        > (std::get<I + 1>(tpl)...);
+    }
+
+    template <typename Head, typename... Tail>
+    std::tuple<Tail...> tuple_tail(const std::tuple<Head, Tail...>& tpl)
+    {
+        return tuple_tail_impl(tpl, make_index_sequence<sizeof...(Tail)>());
+    }
+
+
+    // Forward declaration
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer;
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    inline one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... >
+        make_one_by_one_visitor_and_value_referer(
+            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
+        )
+    {
+        return one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... > (
+            visitor, visitables, values
+        );
+    }
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values...>           values_;
+        Visitables                      visitables_;
+
+    public: // structors
+        one_by_one_visitor_and_value_referer(
+                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+            , visitables_(visitables)
+        {}
+
+    public: // visitor interfaces
+        typedef typename Visitor::result_type result_type;
+
+        template <typename Value>
+        result_type operator()(Value&& value) const
+        {
+            return ::boost::apply_visitor(
+                make_one_by_one_visitor_and_value_referer(
+                    visitor_,
+                    tuple_tail(visitables_),
+                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
+                )
+                , unwrap(std::get<0>(visitables_)) // getting Head element
+            );
+        }
+
+    private:
+        one_by_one_visitor_and_value_referer& operator=(const one_by_one_visitor_and_value_referer&);
+    };
+
+    template <typename Visitor, typename... Values>
+    class one_by_one_visitor_and_value_referer<Visitor, std::tuple<>, Values...>
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values...>           values_;
+
+    public:
+        one_by_one_visitor_and_value_referer(
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+        {}
+
+        typedef typename Visitor::result_type result_type;
+
+        template <class Tuple, std::size_t... I>
+        result_type do_call(Tuple t, index_sequence<I...>) const {
+            return visitor_(unwrap(std::get<I>(t))...);
+        }
+
+        template <typename Value>
+        result_type operator()(Value&& value) const
+        {
+            return do_call(
+                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
+                make_index_sequence<sizeof...(Values) + 1>()
+            );
+        }
+    };
+
+}} // namespace detail::variant
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline typename Visitor::result_type
+        apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
+                visitor,
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
+                std::tuple<>()
+                ),
+                ::boost::forward<T1>(v1)
+            );
+    }
+    
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline typename Visitor::result_type
+        apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
+                visitor,
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
+                std::tuple<>()
+                ),
+                ::boost::forward<T1>(v1)
+            );
+    }
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/multivisitors_cpp14_based.hpp

@@ -0,0 +1,153 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via variadic templates, std::tuple
+//  and decltype(auto)
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-2014.
+//
+//  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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/detail/multivisitors_cpp14_based.hpp>
+#include <tuple>
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+    // Forward declaration
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14;
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    inline one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... >
+        make_one_by_one_visitor_and_value_referer_cpp14(
+            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
+        )
+    {
+        return one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... > (
+            visitor, visitables, values
+        );
+    }
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values...>           values_;
+        Visitables                      visitables_;
+
+    public: // structors
+        one_by_one_visitor_and_value_referer_cpp14(
+                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+            , visitables_(visitables)
+        {}
+
+    public: // visitor interfaces
+        template <typename Value>
+        decltype(auto) operator()(Value&& value) const
+        {
+            return ::boost::apply_visitor(
+                make_one_by_one_visitor_and_value_referer_cpp14(
+                    visitor_,
+                    tuple_tail(visitables_),
+                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
+                )
+                , unwrap(std::get<0>(visitables_)) // getting Head element
+            );
+        }
+
+    private:
+        one_by_one_visitor_and_value_referer_cpp14& operator=(const one_by_one_visitor_and_value_referer_cpp14&);
+    };
+
+    template <typename Visitor, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14<Visitor, std::tuple<>, Values...>
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values...>           values_;
+
+    public:
+        one_by_one_visitor_and_value_referer_cpp14(
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+        {}
+
+        template <class Tuple, std::size_t... I>
+        decltype(auto) do_call(Tuple t, index_sequence<I...>) const {
+            return visitor_(unwrap(std::get<I>(t))...);
+        }
+
+        template <typename Value>
+        decltype(auto) operator()(Value&& value) const
+        {
+            return do_call(
+                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
+                make_index_sequence<sizeof...(Values) + 1>()
+            );
+        }
+    };
+
+}} // namespace detail::variant
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline decltype(auto) apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
+        typename boost::disable_if<
+            boost::detail::variant::has_result_type<Visitor>,
+            bool
+        >::type = true)
+    {
+        return boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
+                visitor,
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
+                std::tuple<>()
+            ),
+            ::boost::forward<T1>(v1)
+        );
+    }
+
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline decltype(auto) apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
+        typename boost::disable_if<
+            boost::detail::variant::has_result_type<Visitor>,
+            bool
+        >::type = true)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
+                visitor,
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
+                std::tuple<>()
+            ),
+            ::boost::forward<T1>(v1)
+        );
+    }
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/multivisitors_preprocessor_based.hpp

@@ -0,0 +1,143 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via preprocessor magic
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-2014.
+//
+//  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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant.hpp>
+#include <boost/bind.hpp>
+
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+
+#ifndef BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS
+#   define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 4
+#endif
+
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    struct two_variables_holder {
+    private:
+        VisitorT&       visitor_;
+        Visitable1T&    visitable1_;
+        Visitable2T&    visitable2_;
+
+        // required to suppress warnings and ensure that we do not copy
+        // this visitor
+        two_variables_holder& operator=(const two_variables_holder&);
+
+    public:
+        typedef BOOST_DEDUCED_TYPENAME VisitorT::result_type result_type;
+
+        explicit two_variables_holder(VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2) BOOST_NOEXCEPT 
+            : visitor_(visitor)
+            , visitable1_(visitable1)
+            , visitable2_(visitable2)
+        {}
+
+#define BOOST_VARIANT_OPERATOR_BEG()                            \
+    return ::boost::apply_visitor(                              \
+    ::boost::bind<result_type>(boost::ref(visitor_), _1, _2     \
+    /**/
+
+#define BOOST_VARIANT_OPERATOR_END()                            \
+    ), visitable1_, visitable2_);                               \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() boost::ref( BOOST_PP_CAT(vis, n) )         \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                     \
+    template <BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 1), class VisitableUnwrapped)>           \
+    result_type operator()(                                                                 \
+        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 1), VisitableUnwrapped, & vis)          \
+    ) const                                                                                 \
+    {                                                                                       \
+        BOOST_VARIANT_OPERATOR_BEG()                                                        \
+        BOOST_PP_REPEAT(BOOST_PP_ADD(n, 1), BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)     \
+        BOOST_VARIANT_OPERATOR_END()                                                        \
+    }                                                                                       \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, ~)
+#undef BOOST_VARIANT_OPERATOR_BEG
+#undef BOOST_VARIANT_OPERATOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+
+    };
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<const VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            const VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<const VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+}} // namespace detail::variant
+
+#define BOOST_VARIANT_APPLY_VISITOR_BEG()                                               \
+    return ::boost::apply_visitor(                                                      \
+            boost::detail::variant::make_two_variables_holder(visitor, var0 , var1),    \
+            var2                                                                        \
+    /**/
+
+#define BOOST_VARIANT_APPLY_VISITOR_END()                       \
+    );                                                          \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() BOOST_PP_CAT(var, BOOST_PP_ADD(n, 3))      \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                                 \
+    template <class Visitor BOOST_PP_COMMA() BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 3), class T)>         \
+    inline BOOST_DEDUCED_TYPENAME Visitor::result_type apply_visitor(                                   \
+        data BOOST_PP_COMMA() BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 3), T, & var)     \
+    )                                                                                                   \
+    {                                                                                                   \
+        BOOST_VARIANT_APPLY_VISITOR_BEG()                                                               \
+        BOOST_PP_REPEAT(n, BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)                                  \
+        BOOST_VARIANT_APPLY_VISITOR_END()                                                               \
+    }                                                                                                   \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, const Visitor& visitor)
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, Visitor& visitor)
+
+#undef BOOST_VARIANT_APPLY_VISITOR_BEG
+#undef BOOST_VARIANT_APPLY_VISITOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+    
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/over_sequence.hpp

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/over_sequence.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// Portions Copyright (C) 2002 David Abrahams
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+#define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class over_sequence
+//
+// Wrapper used to indicate bounded types for variant are from type sequence.
+//
+template <typename Types>
+struct over_sequence
+{
+    typedef Types type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_over_sequence (modeled on code by David Abrahams)
+//
+// Indicates whether the specified type is of form over_sequence<...> or not.
+//
+
+
+template <typename T>
+struct is_over_sequence
+    : mpl::false_
+{
+};
+
+template <typename Types>
+struct is_over_sequence< over_sequence<Types> >
+    : mpl::true_
+{
+};
+
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/std_hash.hpp

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/std_hash.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2018-2022 Antony Polukhin
+//
+// 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)
+
+
+#ifndef BOOST_VARIANT_DETAIL_STD_HASH_HPP
+#define BOOST_VARIANT_DETAIL_STD_HASH_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/detail/hash_variant.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH
+//
+// Define this macro if you do not wish to have a std::hash specialization for
+// boost::variant.
+
+#if !defined(BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#include <functional> // for std::hash
+
+namespace std {
+    template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+    struct hash<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > > {
+        std::size_t operator()(const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& val) const {
+            return ::boost::hash_value(val);
+        }
+    };
+}
+
+#endif // #if !defined(BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#endif // BOOST_VARIANT_DETAIL_STD_HASH_HPP
+

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/substitute.hpp

@@ -0,0 +1,279 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#include <boost/variant/detail/substitute_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#include <boost/mpl/int_fwd.hpp>
+#include <boost/mpl/limits/arity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/iterate.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+
+//
+// primary template
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity /* = ... (see substitute_fwd.hpp) */
+        )
+    >
+struct substitute
+{
+    typedef T type;
+};
+
+//
+// tag substitution specializations
+//
+
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(CV_) \
+    template <typename Dest, typename Source> \
+    struct substitute< \
+          CV_ Source \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef CV_ Dest type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG
+
+//
+// pointer specializations
+//
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(CV_) \
+    template <typename T, typename Dest, typename Source> \
+    struct substitute< \
+          T * CV_ \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef typename substitute< \
+              T, Dest, Source \
+            >::type * CV_ type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER
+
+//
+// reference specializations
+//
+template <typename T, typename Dest, typename Source>
+struct substitute<
+      T&
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+    typedef typename substitute<
+          T, Dest, Source
+        >::type & type;
+};
+
+//
+// template expression (i.e., F<...>) specializations
+//
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+template <
+      template <typename...> class F
+    , typename... Ts
+    , typename Dest
+    , typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      F<Ts...>
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+    typedef F<typename substitute<
+          Ts, Dest, Source
+        >::type...> type;
+};
+
+//
+// function specializations
+//
+template <
+      typename R
+    , typename... A
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)(A...)
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+
+public:
+    typedef r (*type)(typename substitute<
+          A, Dest, Source
+        >::type...);
+};
+#else
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \
+    typedef typename substitute< \
+          BOOST_PP_CAT(U,N), Dest, Source \
+        >::type BOOST_PP_CAT(u,N); \
+    /**/
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \
+    BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \
+    /**/
+
+#define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
+#define BOOST_PP_FILENAME_1 <boost/variant/detail/substitute.hpp>
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF
+
+#endif // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+///// iteration, depth == 1
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+#if i > 0
+
+//
+// template specializations
+//
+template <
+      template < BOOST_MPL_PP_PARAMS(i,typename P) > class T
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< BOOST_MPL_PP_PARAMS(i,U) >
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>)
+    >
+{
+private:
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef T< BOOST_MPL_PP_PARAMS(i,u) > type;
+};
+
+//
+// function specializations
+//
+template <
+      typename R
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( BOOST_MPL_PP_PARAMS(i,U) )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) );
+};
+
+#elif i == 0
+
+//
+// zero-arg function specialization
+//
+template <
+      typename R, typename Dest, typename Source
+    >
+struct substitute<
+      R (*)( void )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+
+public:
+    typedef r (*type)( void );
+};
+
+#endif // i
+
+#undef i
+#endif // BOOST_PP_IS_ITERATING

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/substitute_fwd.hpp

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/template_arity.hpp>
+#include <boost/mpl/int_fwd.hpp>
+
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+//
+// Defined if 'substitute' is not implementable on the current compiler.
+//
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/aux_/config/ttp.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+ && !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+#   define BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity = mpl::int_< mpl::aux::template_arity<T>::value >
+        )
+    >
+struct substitute;
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/variant_io.hpp

@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/variant_io.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
+#define BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
+
+#include <iosfwd> // for std::basic_ostream forward declare
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/detail/templated_streams.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+namespace boost {
+
+///////////////////////////////////////////////////////////////////////////////
+// function template operator<<
+//
+// Outputs the content of the given variant to the given ostream.
+//
+
+// forward declare (allows output of embedded variant< variant< ... >, ... >)
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    );
+
+namespace detail { namespace variant {
+
+template <typename OStream>
+class printer
+    : public boost::static_visitor<>
+{
+private: // representation
+
+    OStream& out_;
+
+public: // structors
+
+    explicit printer(OStream& out)
+        : out_( out )
+    {
+    }
+
+public: // visitor interface
+
+    template <typename T>
+    void operator()(const T& operand) const
+    {
+        out_ << operand;
+    }
+
+private:
+    printer& operator=(const printer&);
+
+};
+
+}} // namespace detail::variant
+
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    )
+{
+    detail::variant::printer<
+          BOOST_TEMPLATED_STREAM(ostream, E,T)
+        > visitor(out);
+
+    rhs.apply_visitor(visitor);
+
+    return out;
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_VARIANT_IO_HPP

externals/vcpkg/packages/boost-variant_x64-windows/include/boost/variant/detail/visitation_impl.hpp

@@ -0,0 +1,277 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/visitation_impl.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
+#define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
+
+#include <boost/config.hpp>
+
+#include <boost/variant/detail/backup_holder.hpp>
+#include <boost/variant/detail/cast_storage.hpp>
+#include <boost/variant/detail/forced_return.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+# pragma warning (push)
+# pragma warning (disable : 4702) //unreachable code
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+//
+// Unrolls variant's visitation mechanism to reduce template instantiation
+// and potentially increase runtime performance. (TODO: Investigate further.)
+//
+#if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+
+#ifndef BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#   include <boost/mpl/limits/list.hpp>
+#   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
+        BOOST_MPL_LIMIT_LIST_SIZE
+#else
+#   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
+        BOOST_VARIANT_LIMIT_TYPES
+#endif
+
+#endif
+
+// Define a compiler generic null pointer value
+#if defined(BOOST_NO_CXX11_NULLPTR)
+#define BOOST_VARIANT_NULL 0
+#else
+#define BOOST_VARIANT_NULL nullptr
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class apply_visitor_unrolled
+//
+// Tag type indicates when visitation_impl is unrolled.
+//
+struct apply_visitor_unrolled {};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template visitation_impl_step
+//
+// "Never ending" iterator range facilitates visitation_impl unrolling.
+//
+
+
+template <typename Iter, typename LastIter>
+struct visitation_impl_step
+{
+    typedef typename mpl::deref<Iter>::type type;
+
+    typedef typename mpl::next<Iter>::type next_iter;
+    typedef visitation_impl_step<
+          next_iter, LastIter
+        > next;
+};
+
+template <typename LastIter>
+struct visitation_impl_step< LastIter,LastIter >
+{
+    typedef apply_visitor_unrolled type;
+    typedef visitation_impl_step next;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl_invoke
+//
+// Invokes the given visitor on the specified type in the given storage.
+//
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline typename Visitor::result_type
+visitation_impl_invoke_impl(
+      int, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::true_// never_uses_backup
+    )
+{
+    return visitor.internal_visit(
+          cast_storage<T>(storage), 1L
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline typename Visitor::result_type
+visitation_impl_invoke_impl(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::false_// never_uses_backup
+    )
+{
+    if (internal_which >= 0)
+    {
+        return visitor.internal_visit(
+              cast_storage<T>(storage), 1L
+            );
+    }
+    else
+    {
+        return visitor.internal_visit(
+              cast_storage< backup_holder<T> >(storage), 1L
+            );
+    }
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
+inline typename Visitor::result_type
+visitation_impl_invoke(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
+    , NoBackupFlag
+    , int
+    )
+{
+    typedef typename mpl::or_<
+          NoBackupFlag
+        , is_nothrow_move_constructible<T>
+        , has_nothrow_copy<T>
+        >::type never_uses_backup;
+
+    return (visitation_impl_invoke_impl)(
+          internal_which, visitor, storage, t
+        , never_uses_backup()
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename NBF>
+inline typename Visitor::result_type
+visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
+{
+    // should never be here at runtime!
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl
+//
+// Invokes the given visitor on the type in the given variant storage.
+//
+
+template <
+      typename W, typename S
+    , typename Visitor, typename VPCV
+    , typename NBF
+    >
+inline typename Visitor::result_type
+visitation_impl(
+      int, int, Visitor&, VPCV
+    , mpl::true_ // is_apply_visitor_unrolled
+    , NBF, W* = BOOST_VARIANT_NULL, S* = BOOST_VARIANT_NULL
+    )
+{
+    // should never be here at runtime!
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+template <
+      typename Which, typename step0
+    , typename Visitor, typename VoidPtrCV
+    , typename NoBackupFlag
+    >
+BOOST_FORCEINLINE typename Visitor::result_type
+visitation_impl(
+      const int internal_which, const int logical_which
+    , Visitor& visitor, VoidPtrCV storage
+    , mpl::false_ // is_apply_visitor_unrolled
+    , NoBackupFlag no_backup_flag
+    , Which* = BOOST_VARIANT_NULL, step0* = BOOST_VARIANT_NULL
+    )
+{
+    // Typedef apply_visitor_unrolled steps and associated types...
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF(z, N, _) \
+    typedef typename BOOST_PP_CAT(step,N)::type BOOST_PP_CAT(T,N); \
+    typedef typename BOOST_PP_CAT(step,N)::next \
+        BOOST_PP_CAT(step, BOOST_PP_INC(N)); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+
+    // ...switch on the target which-index value...
+    switch (logical_which)
+    {
+
+    // ...applying the appropriate case:
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE(z, N, _) \
+    case (Which::value + (N)): \
+        return (visitation_impl_invoke)( \
+              internal_which, visitor, storage \
+            , static_cast<BOOST_PP_CAT(T,N)*>(0) \
+            , no_backup_flag, 1L \
+            ); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+
+    default: break;
+    }
+
+    // If not handled in this iteration, continue unrolling:
+    typedef mpl::int_<
+          Which::value + (BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        > next_which;
+
+    typedef BOOST_PP_CAT(step, BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        next_step;
+
+    typedef typename next_step::type next_type;
+    typedef typename is_same< next_type,apply_visitor_unrolled >::type
+        is_apply_visitor_unrolled;
+
+    return detail::variant::visitation_impl(
+          internal_which, logical_which
+        , visitor, storage
+        , is_apply_visitor_unrolled()
+        , no_backup_flag
+        , static_cast<next_which*>(0), static_cast<next_step*>(0)
+        );
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP