passenger 6.0.6 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/typeof/register_functions_iterate.hpp

@@ -1,135 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/typeof/encode_decode_params.hpp>
-
-#define n BOOST_PP_ITERATION()
-
-// function pointers
-
-template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P))>
-{
-    typedef R BOOST_PP_CAT(P, n);
-    typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_PTR_ID + n) type;
-};
-
-template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
-{
-    typedef R BOOST_PP_CAT(P, n);
-    typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_PTR_ID + n) type;
-};
-
-template<class Iter>
-struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_PTR_ID + n>, Iter>
-{
-    typedef Iter iter0;
-    BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-    typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p));
-    typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-};
-
-template<class Iter>
-struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_VAR_PTR_ID + n>, Iter>
-{
-    typedef Iter iter0;
-    BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-    typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
-    typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-};
-
-#ifndef BOOST_TYPEOF_NO_FUNCTION_TYPES
-
-    // function references
-
-    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-    struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P))>
-    {
-        typedef R BOOST_PP_CAT(P, n);
-        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_REF_ID + n) type;
-    };
-
-    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-    struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
-    {
-        typedef R BOOST_PP_CAT(P, n);
-        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_REF_ID + n) type;
-    };
-
-    template<class Iter>
-    struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_REF_ID + n>, Iter>
-    {
-        typedef Iter iter0;
-        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-        typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p));
-        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-    };
-
-    template<class Iter>
-    struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_VAR_REF_ID + n>, Iter>
-    {
-        typedef Iter iter0;
-        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-        typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
-        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-    };
-
-    // functions
-
-    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-    struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P))>
-    {
-        typedef R BOOST_PP_CAT(P, n);
-        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_ID + n) type;
-    };
-
-    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
-    struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P) ...)>
-    {
-        typedef R BOOST_PP_CAT(P, n);
-        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_ID + n) type;
-    };
-
-    template<class Iter>
-    struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_ID + n>, Iter>
-    {
-        typedef Iter iter0;
-        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-        typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p));
-        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-    };
-
-    template<class Iter>
-    struct decode_type_impl<boost::type_of::constant<std::size_t,FUN_VAR_ID + n>, Iter>
-    {
-        typedef Iter iter0;
-        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
-        typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
-        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
-    };
-
-#endif//BOOST_TYPEOF_NO_FUNCTION_TYPES
-
-#ifndef BOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES
-// member functions
-
-#define BOOST_TYPEOF_qualifier
-#define BOOST_TYPEOF_id MEM_FUN_ID
-#include <boost/typeof/register_mem_functions.hpp>
-
-#define BOOST_TYPEOF_qualifier const
-#define BOOST_TYPEOF_id CONST_MEM_FUN_ID
-#include <boost/typeof/register_mem_functions.hpp>
-
-#define BOOST_TYPEOF_qualifier volatile
-#define BOOST_TYPEOF_id VOLATILE_MEM_FUN_ID
-#include <boost/typeof/register_mem_functions.hpp>
-
-#define BOOST_TYPEOF_qualifier volatile const
-#define BOOST_TYPEOF_id VOLATILE_CONST_MEM_FUN_ID
-#include <boost/typeof/register_mem_functions.hpp>
-
-#undef n
-#endif

data/src/cxx_supportlib/vendor-modified/boost/typeof/register_fundamental.hpp

@@ -1,61 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
-#define BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
-
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-BOOST_TYPEOF_REGISTER_TYPE(unsigned char)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned short)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned int)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned long)
-
-BOOST_TYPEOF_REGISTER_TYPE(signed char)
-BOOST_TYPEOF_REGISTER_TYPE(signed short)
-BOOST_TYPEOF_REGISTER_TYPE(signed int)
-BOOST_TYPEOF_REGISTER_TYPE(signed long)
-
-BOOST_TYPEOF_REGISTER_TYPE(bool)
-BOOST_TYPEOF_REGISTER_TYPE(char)
-
-BOOST_TYPEOF_REGISTER_TYPE(float)
-BOOST_TYPEOF_REGISTER_TYPE(double)
-BOOST_TYPEOF_REGISTER_TYPE(long double)
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-// If the following line fails to compile and you're using the Intel
-// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
-// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
-BOOST_TYPEOF_REGISTER_TYPE(wchar_t)
-#endif
-
-#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
-    || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER == 1200))
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int8)
-BOOST_TYPEOF_REGISTER_TYPE(__int8)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int16)
-BOOST_TYPEOF_REGISTER_TYPE(__int16)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int32)
-BOOST_TYPEOF_REGISTER_TYPE(__int32)
-#ifdef __BORLANDC__
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
-BOOST_TYPEOF_REGISTER_TYPE(__int64)
-#endif
-#endif
-
-# if defined(BOOST_HAS_LONG_LONG)
-BOOST_TYPEOF_REGISTER_TYPE(::boost::ulong_long_type)
-BOOST_TYPEOF_REGISTER_TYPE(::boost::long_long_type)
-#elif defined(BOOST_HAS_MS_INT64)
-BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
-BOOST_TYPEOF_REGISTER_TYPE(__int64)
-#endif
-
-BOOST_TYPEOF_REGISTER_TYPE(void)
-
-#endif//BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/register_mem_functions.hpp

@@ -1,32 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/typeof/encode_decode_params.hpp>
-
-// member functions
-
-template<class V, class T, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> 
-struct encode_type_impl<V, R(T::*)(BOOST_PP_ENUM_PARAMS(n, P)) BOOST_TYPEOF_qualifier>
-{
-    typedef R BOOST_PP_CAT(P, n);
-    typedef T BOOST_PP_CAT(P, BOOST_PP_INC(n));
-    typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_ADD(n, 2), BOOST_TYPEOF_id + n) type;
-};
-
-template<class Iter>
-struct decode_type_impl<boost::type_of::constant<std::size_t,BOOST_TYPEOF_id + n>, Iter>
-{
-    typedef Iter iter0;
-    BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_ADD(n, 2))
-    template<class T> struct workaround{
-        typedef BOOST_PP_CAT(p, n)(T::*type)(BOOST_PP_ENUM_PARAMS(n, p)) BOOST_TYPEOF_qualifier;
-    };
-    typedef typename workaround<BOOST_PP_CAT(p, BOOST_PP_INC(n))>::type type;
-    typedef BOOST_PP_CAT(iter, BOOST_PP_ADD(n, 2)) iter;
-};
-
-// undef parameters
-
-#undef BOOST_TYPEOF_id
-#undef BOOST_TYPEOF_qualifier

data/src/cxx_supportlib/vendor-modified/boost/typeof/template_encoding.hpp

@@ -1,160 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// Copyright (C) 2005 Peder Holt
-// 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_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
-
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repetition/enum_trailing.hpp>
-#include <boost/preprocessor/control/iif.hpp>
-#include <boost/preprocessor/detail/is_unary.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/tuple/eat.hpp>
-#include <boost/preprocessor/seq/transform.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/seq/cat.hpp>
-
-#include <boost/typeof/encode_decode.hpp>
-#include <boost/typeof/int_encoding.hpp>
-
-#include <boost/typeof/type_template_param.hpp>
-#include <boost/typeof/integral_template_param.hpp>
-#include <boost/typeof/template_template_param.hpp>
-
-#ifdef __BORLANDC__
-#define BOOST_TYPEOF_QUALIFY(P) self_t::P
-#else
-#define BOOST_TYPEOF_QUALIFY(P) P
-#endif
-// The template parameter description, entered by the user,
-// is converted into a polymorphic "object"
-// that is used to generate the code responsible for
-// encoding/decoding the parameter, etc.
-
-// make sure to cat the sequence first, and only then add the prefix.
-#define BOOST_TYPEOF_MAKE_OBJ(elem) BOOST_PP_CAT(\
-    BOOST_TYPEOF_MAKE_OBJ,\
-    BOOST_PP_SEQ_CAT((_) BOOST_TYPEOF_TO_SEQ(elem))\
-    )
-
-#define BOOST_TYPEOF_TO_SEQ(tokens) BOOST_TYPEOF_ ## tokens ## _BOOST_TYPEOF
-
-// BOOST_TYPEOF_REGISTER_TEMPLATE
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, Id)\
-    BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(\
-        Name,\
-        BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TOSEQ(Params)),\
-        BOOST_PP_SEQ_SIZE(BOOST_TYPEOF_TOSEQ(Params)),\
-        Id)
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE(Name, Params)\
-    BOOST_TYPEOF_REGISTER_TEMPLATE_EXPLICIT_ID(Name, Params, BOOST_TYPEOF_UNIQUE_ID())
-
-#define BOOST_TYPEOF_OBJECT_MAKER(s, data, elem)\
-    BOOST_TYPEOF_MAKE_OBJ(elem)
-
-#define BOOST_TYPEOF_MAKE_OBJS(Params)\
-    BOOST_PP_SEQ_TRANSFORM(BOOST_TYPEOF_OBJECT_MAKER, ~, Params)
-
-// As suggested by Paul Mensonides:
-
-#define BOOST_TYPEOF_TOSEQ(x)\
-    BOOST_PP_IIF(\
-        BOOST_PP_IS_UNARY(x),\
-        x BOOST_PP_TUPLE_EAT(3), BOOST_PP_REPEAT\
-    )(x, BOOST_TYPEOF_TOSEQ_2, ~)
-
-#define BOOST_TYPEOF_TOSEQ_2(z, n, _) (class)
-
-// BOOST_TYPEOF_VIRTUAL
-
-#define BOOST_TYPEOF_CAT_4(a, b, c, d) BOOST_TYPEOF_CAT_4_I(a, b, c, d)
-#define BOOST_TYPEOF_CAT_4_I(a, b, c, d) a ## b ## c ## d
-
-#define BOOST_TYPEOF_VIRTUAL(Fun, Obj)\
-    BOOST_TYPEOF_CAT_4(BOOST_TYPEOF_, BOOST_PP_SEQ_HEAD(Obj), _, Fun)
-
-// BOOST_TYPEOF_SEQ_ENUM[_TRAILING][_1]
-// Two versions provided due to reentrancy issue
-
-#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT(z,n,seq)\
-   BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
-
-#define BOOST_TYPEOF_SEQ_ENUM(seq,macro)\
-    BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
-
-#define BOOST_TYPEOF_SEQ_ENUM_TRAILING(seq,macro)\
-    BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
-
-#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1(z,n,seq)\
-    BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
-
-#define BOOST_TYPEOF_SEQ_ENUM_1(seq,macro)\
-    BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
-
-#define BOOST_TYPEOF_SEQ_ENUM_TRAILING_1(seq,macro)\
-    BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
-
-//
-
-#define BOOST_TYPEOF_PLACEHOLDER(z, n, elem)\
-    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER, elem)(elem)
-
-#define BOOST_TYPEOF_PLACEHOLDER_TYPES(z, n, elem)\
-    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER_TYPES, elem)(elem, n)
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
-    BOOST_TYPEOF_VIRTUAL(ENCODE, elem)(elem, n)
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
-    BOOST_TYPEOF_VIRTUAL(DECODE, elem)(elem, n)
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z, n, elem) \
-    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(P, n)
-
-#define BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\
-    Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) >
-
-//Since we are creating an internal decode struct, we need to use different template names, T instead of P.
-#define BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
-    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(T, n)
-
-//Default template param decoding
-
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE(Name,Params)\
-    typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),BOOST_TYPEOF_QUALIFY(P))> type;
-
-//Branch the decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name,Params)\
-    BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
-        BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE,\
-        BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE)(Name,Params)
-
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(Name, Params, Size, ID)\
-    BOOST_TYPEOF_BEGIN_ENCODE_NS\
-    BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name, Params, ID)\
-    template<class V\
-        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params, BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
-    >\
-    struct encode_type_impl<V, Name<BOOST_PP_ENUM_PARAMS(Size, P)> >\
-    {\
-        typedef typename boost::type_of::push_back<V, boost::type_of::constant<std::size_t,ID> >::type V0;\
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM, ~, Params)\
-        typedef BOOST_PP_CAT(V, Size) type;\
-    };\
-    template<class Iter>\
-    struct decode_type_impl<boost::type_of::constant<std::size_t,ID>, Iter>\
-    {\
-        typedef decode_type_impl<boost::type_of::constant<std::size_t,ID>, Iter> self_t;\
-        typedef boost::type_of::constant<std::size_t,ID> self_id;\
-        typedef Iter iter0;\
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM, ~, Params)\
-        BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name, Params)\
-        typedef BOOST_PP_CAT(iter, Size) iter;\
-    };\
-    BOOST_TYPEOF_END_ENCODE_NS
-
-#endif//BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/template_template_param.hpp

@@ -1,149 +0,0 @@
-// Copyright (C) 2005 Peder Holt
-// Copyright (C) 2005 Arkadiy Vertleyb
-// 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_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
-
-#include <boost/preprocessor/logical/or.hpp>
-#include <boost/preprocessor/seq/fold_left.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-
-#define BOOST_TYPEOF_MAKE_OBJ_template(x)   BOOST_TYPEOF_TEMPLATE_PARAM(x)
-#define BOOST_TYPEOF_TEMPLATE(X) template(X) BOOST_TYPEOF_EAT
-#define BOOST_TYPEOF_template(X) (template(X))
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM(Params)\
-    (TEMPLATE_PARAM)\
-    (Params)
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)\
-    BOOST_TYPEOF_TOSEQ(BOOST_PP_SEQ_ELEM(1, This))
-
-//Encode / decode this
-#define BOOST_TYPEOF_TEMPLATE_PARAM_ENCODE(This, n)\
-   typedef typename boost::type_of::encode_template<BOOST_PP_CAT(V, n),\
-       BOOST_PP_CAT(P, n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)),BOOST_TYPEOF_PLACEHOLDER) >\
-   >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM_DECODE(This, n)\
-   typedef boost::type_of::decode_template< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
-   typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
-   typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
-
-// template<class, unsigned int, ...> class
-#define BOOST_TYPEOF_TEMPLATE_PARAM_EXPANDTYPE(This) \
-    template <BOOST_PP_SEQ_ENUM(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)) > class
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER(Param)\
-    Nested_Template_Template_Arguments_Not_Supported
-
-//'template<class,int> class' is reduced to 'class'
-#define BOOST_TYPEOF_TEMPLATE_PARAM_DECLARATION_TYPE(Param) class
-
-// T3<int, (unsigned int)0, ...>
-#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER_TYPES(Param, n)\
-    BOOST_PP_CAT(T,n)<BOOST_TYPEOF_SEQ_ENUM_1(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(Param)),BOOST_TYPEOF_PLACEHOLDER) >
-
-#define BOOST_TYPEOF_TEMPLATE_PARAM_ISTEMPLATE 1
-
-////////////////////////////
-// move to encode_decode?
-
-BOOST_TYPEOF_BEGIN_ENCODE_NS
-
-template<class V, class Type_Not_Registered_With_Typeof_System> struct encode_template_impl;
-template<class T, class Iter> struct decode_template_impl;
-
-BOOST_TYPEOF_END_ENCODE_NS
-
-namespace boost { namespace type_of {
-
-    template<class V, class T> struct encode_template
-        : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_template_impl<V, T>
-    {};
-
-    template<class Iter> struct decode_template
-        : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_template_impl<typename Iter::type, typename Iter::next>
-    {};
-}}
-
-////////////////////////////
-// move to template_encoding.hpp?
-
-//Template template registration
-#define BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE(Name,Params,ID)\
-    template<class V\
-        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
-    >\
-    struct encode_template_impl<V,Name<\
-        BOOST_PP_ENUM_PARAMS(\
-        BOOST_PP_SEQ_SIZE(Params),\
-        P)> >\
-        : boost::type_of::push_back<V, boost::type_of::constant<std::size_t,ID> >\
-    {\
-    };\
-    template<class Iter> struct decode_template_impl<boost::type_of::constant<std::size_t,ID>, Iter>\
-    {\
-        BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(Params),BOOST_TYPEOF_TYPEDEF_INT_PN,_)\
-        typedef Name<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER) > type;\
-        typedef Iter iter;\
-    };
-
-#define BOOST_TYPEOF_TYPEDEF_INT_PN(z,n,Params) typedef int BOOST_PP_CAT(P,n);
-
-#ifdef __BORLANDC__
-#define BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME BOOST_PP_CAT(\
-        BOOST_PP_CAT(\
-            BOOST_PP_CAT(\
-                decode_nested_template_helper,\
-                BOOST_TYPEOF_REGISTRATION_GROUP\
-            ),0x10000\
-        ),__LINE__\
-    )
-#define BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)\
-    struct BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME {\
-        template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
-        struct decode_params;\
-        template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
-        struct decode_params<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER_TYPES) >\
-        {\
-            typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),T)> type;\
-        };\
-    };
-//Template template param decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
-    typedef typename BOOST_TYPEOF_DECODE_NESTED_TEMPLATE_HELPER_NAME::decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
-
-#else
-#define BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL(Name,Params,ID)
-
-//Template template param decoding
-#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
-    template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR) >\
-    struct decode_params;\
-    template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR) >\
-    struct decode_params<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER_TYPES) >\
-    {\
-        typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),T)> type;\
-    };\
-    typedef typename decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
-#endif
-#define BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
-    BOOST_TYPEOF_VIRTUAL(DECLARATION_TYPE, elem)(elem) BOOST_PP_CAT(T, n)
-
-// BOOST_TYPEOF_HAS_TEMPLATES
-#define BOOST_TYPEOF_HAS_TEMPLATES(Params)\
-    BOOST_PP_SEQ_FOLD_LEFT(BOOST_TYPEOF_HAS_TEMPLATES_OP, 0, Params)
-
-#define BOOST_TYPEOF_HAS_TEMPLATES_OP(s, state, elem)\
-    BOOST_PP_OR(state, BOOST_TYPEOF_VIRTUAL(ISTEMPLATE, elem))
-
-//Define template template arguments
-#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,ID)\
-    BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
-        BOOST_TYPEOF_REGISTER_DECODE_NESTED_TEMPLATE_HELPER_IMPL,\
-        BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE)(Name,Params,ID)
-
-#endif //BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/type_encoding.hpp

@@ -1,27 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// 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_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
-
-#define BOOST_TYPEOF_REGISTER_TYPE_IMPL(T, Id)                          \
-                                                                        \
-    template<class V> struct encode_type_impl<V, T >                    \
-        : boost::type_of::push_back<V, boost::type_of::constant<std::size_t,Id> >         \
-    {};                                                                 \
-    template<class Iter> struct decode_type_impl<boost::type_of::constant<std::size_t,Id>, Iter> \
-    {                                                                   \
-        typedef T type;                                                 \
-        typedef Iter iter;                                              \
-    };
-
-#define BOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, Id)                \
-    BOOST_TYPEOF_BEGIN_ENCODE_NS                                        \
-    BOOST_TYPEOF_REGISTER_TYPE_IMPL(Type, Id)                           \
-    BOOST_TYPEOF_END_ENCODE_NS
-
-#define BOOST_TYPEOF_REGISTER_TYPE(Type)                                \
-    BOOST_TYPEOF_REGISTER_TYPE_EXPLICIT_ID(Type, BOOST_TYPEOF_UNIQUE_ID())
-
-#endif//BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/type_template_param.hpp

@@ -1,37 +0,0 @@
-// Copyright (C) 2005 Arkadiy Vertleyb
-// 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_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
-
-#define BOOST_TYPEOF_class_BOOST_TYPEOF (class)
-#define BOOST_TYPEOF_typename_BOOST_TYPEOF (typename)
-
-#define BOOST_TYPEOF_MAKE_OBJ_class BOOST_TYPEOF_TYPE_PARAM
-#define BOOST_TYPEOF_MAKE_OBJ_typename BOOST_TYPEOF_TYPE_PARAM
-
-#define BOOST_TYPEOF_TYPE_PARAM\
-    (TYPE_PARAM)
-
-#define BOOST_TYPEOF_TYPE_PARAM_EXPANDTYPE(Param) class
-
-// TYPE_PARAM "virtual functions" implementation
-
-#define BOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
-    typedef typename boost::type_of::encode_type<\
-        BOOST_PP_CAT(V, n),\
-        BOOST_PP_CAT(P, n)\
-    >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
-
-#define BOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
-    typedef boost::type_of::decode_type< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
-    typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
-    typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
-
-#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER(Param) int
-#define BOOST_TYPEOF_TYPE_PARAM_DECLARATION_TYPE(Param) class
-#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER_TYPES(Param, n) BOOST_PP_CAT(T,n)
-#define BOOST_TYPEOF_TYPE_PARAM_ISTEMPLATE 0
-
-#endif//BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED