summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2010-08-08 18:41:53 (GMT)
committerRemko Tronçon <git@el-tramo.be>2010-08-08 18:41:53 (GMT)
commit19df82042f44c201e5a2821b4fa35465e33a1c90 (patch)
tree1746bddfa31ce2a6488ef5186036a049a255c9da /3rdParty/Boost/src/boost/variant/detail/initializer.hpp
parent4a5a0977f661bf5c7c34ee7aa48b35073a682203 (diff)
downloadswift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.zip
swift-contrib-19df82042f44c201e5a2821b4fa35465e33a1c90.tar.bz2
Added XEP-0004 data forms parsing & serializing.
Diffstat (limited to '3rdParty/Boost/src/boost/variant/detail/initializer.hpp')
-rw-r--r--3rdParty/Boost/src/boost/variant/detail/initializer.hpp265
1 files changed, 265 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/variant/detail/initializer.hpp b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp
new file mode 100644
index 0000000..b14d6c8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/variant/detail/initializer.hpp
@@ -0,0 +1,265 @@
+//-----------------------------------------------------------------------------
+// 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"
+
+#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;
+ typedef typename call_traits<public_T>::param_type
+ param_T;
+
+ 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
+ }
+
+ };
+
+ 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)
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+ BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+ /**/
+
+ #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); \
+ /**/
+
+# else // MSVC7 and below
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+ BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+ , BOOST_VARIANT_ENUM_PARAMS(typename param_T) \
+ /**/
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+ /**/
+
+# endif // MSVC7 and below workaround
+
+template < BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS >
+struct preprocessor_list_initializer
+{
+public: // static functions
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
+ BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_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
+
+};
+
+# if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+
+#if !defined(BOOST_VARIANT_AUX_ECHO)
+# define BOOST_VARIANT_AUX_ECHO(z,N,token) token
+#endif
+
+template <>
+struct preprocessor_list_initializer<
+ BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, int)
+ , BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, const int)
+ >
+{
+};
+
+# endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround
+
+#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)
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+ BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+ /**/
+
+# else // MSVC7 and below
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE(z,N,T) \
+ ::boost::call_traits< \
+ ::boost::unwrap_recursive<BOOST_PP_CAT(T,N)>::type \
+ >::param_type \
+ /**/
+
+ #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+ BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+ , BOOST_PP_ENUM( \
+ BOOST_VARIANT_LIMIT_TYPES \
+ , BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE \
+ , typename_base \
+ ) \
+ /**/
+
+# endif // MSVC7 workaround
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+ ::boost::detail::variant::preprocessor_list_initializer< \
+ BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+ > \
+ /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP