From 634d0108108f32a763dfda1669334ad0813dcba1 Mon Sep 17 00:00:00 2001 From: Peder Holt Date: Thu, 27 Jan 2005 20:52:10 +0000 Subject: [PATCH] Implemented support for template template arguments. [SVN r2469] --- genreg/main.cpp | 10 +- .../compliant/register_template_template.hpp | 194 ++++++++++++++++++ .../typeof/compliant/template_encoding.hpp | 39 ++-- include/boost/typeof/register_integral.hpp | 66 ++++-- include/boost/typeof/std/deque.hpp | 4 +- include/boost/typeof/std/fstream.hpp | 16 +- include/boost/typeof/std/iostream.hpp | 4 +- include/boost/typeof/std/istream.hpp | 8 +- include/boost/typeof/std/iterator.hpp | 48 ++--- include/boost/typeof/std/list.hpp | 4 +- include/boost/typeof/std/map.hpp | 12 +- include/boost/typeof/std/ostream.hpp | 4 +- include/boost/typeof/std/queue.hpp | 4 +- include/boost/typeof/std/set.hpp | 12 +- include/boost/typeof/std/sstream.hpp | 24 +-- include/boost/typeof/std/stack.hpp | 4 +- include/boost/typeof/std/streambuf.hpp | 4 +- include/boost/typeof/std/string.hpp | 6 +- include/boost/typeof/std/vector.hpp | 4 +- include/boost/typeof/typeof.hpp | 5 + .../typeof/vintage/template_encoding.hpp | 5 + test/main.cpp | 16 ++ 22 files changed, 346 insertions(+), 147 deletions(-) create mode 100644 include/boost/typeof/compliant/register_template_template.hpp diff --git a/genreg/main.cpp b/genreg/main.cpp index 7c96b7f..9cb20cc 100755 --- a/genreg/main.cpp +++ b/genreg/main.cpp @@ -96,16 +96,12 @@ public: catch(const runtime_error&) {} - for (int i = nMin; i <= nMax; ++i) + for (int i = nMin; i < nMax; ++i) { - if (i == nMin && i != nMax) - m_out << "#ifdef BOOST_TYPEOF_COMPLIANT" << endl; + m_out << "BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(" << name << ", " << i << ")" << endl; - if (i == nMax && i != nMin) - m_out << "#endif//BOOST_TYPEOF_COMPLIANT" << endl; - - m_out << "BOOST_TYPEOF_REGISTER_TEMPLATE(" << name << ", " << i << ")" << endl; } + m_out << "BOOST_TYPEOF_REGISTER_TEMPLATE(" << name << ", " << nMax << ")" << endl; } else if (what == "TYPE") { diff --git a/include/boost/typeof/compliant/register_template_template.hpp b/include/boost/typeof/compliant/register_template_template.hpp new file mode 100644 index 0000000..5792e3e --- /dev/null +++ b/include/boost/typeof/compliant/register_template_template.hpp @@ -0,0 +1,194 @@ +// Copyright (C) 2005 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_COMPLIANT_REGISTER_TEMPLATE_TEMPLATE_HPP_INCLUDED +#define BOOST_TYPEOF_COMPLIANT_REGISTER_TEMPLATE_TEMPLATE_HPP_INCLUDED + +#include +#include +#include + +namespace boost{namespace type_of {namespace { + template + struct decode_template_impl; + + template struct decode_template + : decode_template_impl::type, typename mpl::next::type> + {}; +}}} + +#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(Type)\ + (TEMPLATE_PARAM)\ + (Type)\ + (class) + +#define BOOST_TYPEOF_ENCODE_TEMPLATE_PARAM(This, n)\ + typedef typename BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME(encode_template,This)<\ + BOOST_PP_CAT(V, n),\ + BOOST_PP_CAT(P, n)\ + >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); + +#define BOOST_TYPEOF_DECODE_TEMPLATE_PARAM(This, n)\ + typedef 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)); + +//In order to handle template template arguments correctly, we need to expand +//e.g (typename)(typename) to template class. +#define BOOST_TYPEOF_EXPAND_TEMPLATE_PARAM(Param)\ + template class + +#define BOOST_TYPEOF_EXPAND_TEMPLATE_PARAM_IMPL(Param)\ + BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(Param),BOOST_TYPEOF_EXPAND_TEMPLATE_ELEMENT,Param) + +#define BOOST_TYPEOF_EXPAND_TEMPLATE_ELEMENT(z,n,Param) BOOST_PP_SEQ_ELEM(n, Param) + +//This is used during decode of template template arguments, tt arguments are wrapped inside encode_template_... +//and the decode_template_... must define a class PN for these arguments. +#define BOOST_TYPEOF_COMPACT_TEMPLATE_PARAM(Param) class +#define BOOST_TYPEOF_COMPACT_TYPE_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) +#define BOOST_TYPEOF_COMPACT_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) +#define BOOST_TYPEOF_COMPACT_EXPLICIT_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) + +#define BOOST_TYPEOF_COMPACT_TYPE(Param)\ + BOOST_PP_CAT(BOOST_TYPEOF_COMPACT_, BOOST_PP_SEQ_ELEM(0, Param))(Param) + +//Again, decode_template_... specializations must expand to encode_template_.... +#define BOOST_TYPEOF_WRAPPED_TEMPLATE_PARAM(n,Param) BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME(encode_template,Param),BOOST_PP_CAT(P,n)> +#define BOOST_TYPEOF_WRAPPED_TYPE_PARAM(n,Param) BOOST_PP_CAT(P,n) +#define BOOST_TYPEOF_WRAPPED_INTEGRAL_PARAM(n,Param) BOOST_PP_CAT(P,n) +#define BOOST_TYPEOF_WRAPPED_EXPLICIT_INTEGRAL_PARAM(n,Param) BOOST_PP_CAT(P,n) + +#define BOOST_TYPEOF_WRAPPED_TYPE_IMPL(n,Param)\ + BOOST_PP_CAT(BOOST_TYPEOF_WRAPPED_, BOOST_PP_SEQ_ELEM(0, Param))(n,Param) + +#define BOOST_TYPEOF_WRAPPED_TYPE(z,n,Params)\ + BOOST_TYPEOF_WRAPPED_TYPE_IMPL(n,BOOST_TYPEOF_MAKE_OBJ(BOOST_PP_SEQ_ELEM(n, Params))) + + +//We need to generate a unique name for template template registration: +#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME(prefix,Params)\ + BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(prefix,BOOST_TYPEOF_PARAM_GETTYPE(Params)) + +#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(prefix,Params)\ + BOOST_PP_SEQ_FOLD_LEFT(\ + BOOST_TYPEOF_TEMPLATE_TEMPLATE_CAT,\ + BOOST_PP_SEQ_HEAD((prefix)Params),\ + BOOST_PP_SEQ_TAIL((prefix)Params)\ + ) + +#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_CAT(s,state,x)\ + BOOST_PP_SEQ_CAT((state)(_)(BOOST_TYPEOF_PARAM_GETNAME(BOOST_TYPEOF_MAKE_OBJ(x)))) + +//Category: Can this parameter be used in a template template class? +//0 -> Not supported +//1 -> Simple type +//2 -> Template template type (can not be used to create template template template types :) +#define BOOST_TYPEOF_PARAM_TT_CATEGORY(Param) \ + BOOST_PP_CAT(BOOST_TYPEOF_TT_CATEGORY_,BOOST_PP_SEQ_ELEM(0, Param)) +#define BOOST_TYPEOF_TT_CATEGORY_INTEGRAL_PARAM 1 +#define BOOST_TYPEOF_TT_CATEGORY_TYPE_PARAM 1 +#define BOOST_TYPEOF_TT_CATEGORY_EXPLICIT_INTEGRAL_PARAM 0 +#define BOOST_TYPEOF_TT_CATEGORY_TEMPLATE_PARAM 2 + +#define BOOST_TYPEOF_CHECK_TT_CATEGORY(s, data, elem)\ + BOOST_PP_EQUAL(BOOST_TYPEOF_PARAM_TT_CATEGORY(BOOST_TYPEOF_MAKE_OBJ(elem)), data) +//BOOST_TYPEOF_PARAM_TT_CATEGORY(BOOST_TYPEOF_MAKE_OBJ(elem)) +//Test if the current template arguments support template template encoding +#define BOOST_TYPEOF_SUPPORT_TEMPLATE_TEMPLATE_ENCODING(Params)\ + BOOST_PP_EQUAL(\ + BOOST_PP_DEC(\ + BOOST_PP_SEQ_SIZE(\ + (_)BOOST_PP_SEQ_FILTER(BOOST_TYPEOF_CHECK_TT_CATEGORY,1,Params)\ + )\ + ),\ + BOOST_PP_SEQ_SIZE(Params)\ + ) + +//Check if one of the arguments is a template template argument. +#define BOOST_TYPEOF_HAS_TEMPLATE_TEMPLATE_ARGUMENTS(Params)\ + BOOST_PP_NOT_EQUAL(\ + BOOST_PP_SEQ_SIZE(\ + (_)BOOST_PP_SEQ_FILTER(BOOST_TYPEOF_CHECK_TT_CATEGORY,2,Params)\ + ),\ + 1\ + ) + +//Return the sequence of template template arguments +#define BOOST_TYPEOF_GET_TEMPLATE_TEMPLATE_SEQUENCES(Params)\ + BOOST_PP_SEQ_FILTER(BOOST_TYPEOF_CHECK_TT_CATEGORY,2,Params) + +//Define template template arguments +#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,ID)\ + BOOST_PP_IF(BOOST_TYPEOF_SUPPORT_TEMPLATE_TEMPLATE_ENCODING(Params),\ + BOOST_TYPEOF_REGISTER_THIS_FOR_TT_ENCODING,\ + BOOST_TYPEOF_REGISTER_ARGUMENTS_FOR_TT_ENCODING)(Name,Params,ID) + + +//Define template template params +#define BOOST_TYPEOF_REGISTER_THIS_FOR_TT_ENCODING(Name,Params,ID)\ + template\ + struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(encode_template,Params);\ + template\ + struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(encode_template,Params)\ + : BOOST_TYPEOF_PUSH_BACK >\ + {};\ + template struct decode_template_impl, Iter> \ + {\ + typedef BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(encode_template,Params)<\ + boost::mpl::vector0<>,\ + Name\ + > type;\ + typedef Iter iter;\ + }; + +//Check if one of the arguments needs to be predeclared +#define BOOST_TYPEOF_REGISTER_ARGUMENTS_FOR_TT_ENCODING(Name,Params,ID)\ + BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENTS(Name,Params,ID,(_)BOOST_TYPEOF_GET_TEMPLATE_TEMPLATE_SEQUENCES(Params)) + +#define BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENTS(Name,Params,ID,TTParams)\ + BOOST_PP_CAT(\ + BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENTS_,\ + BOOST_PP_NOT_EQUAL(BOOST_PP_SEQ_SIZE(TTParams),1)\ + )(Name,Params,ID,TTParams) + +#define BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENTS_0(Name,Params,ID,TTParams)\ + +//We have template template arguments, we need to implement a special decoding for this. +#define BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENTS_1(Name,Params,ID,TTParams)\ + BOOST_PP_SEQ_FOR_EACH(BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENT,_,BOOST_PP_SEQ_POP_FRONT(TTParams))\ + template\ + struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(decode_template,Params);\ + template<\ + BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\ + >\ + struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(decode_template,Params)<\ + boost::mpl::size_t BOOST_PP_ENUM_TRAILING(\ + BOOST_PP_SEQ_SIZE(Params),\ + BOOST_TYPEOF_WRAPPED_TYPE,\ + Params\ + ) > {\ + typedef Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) > type;\ + }; + +//Make the signature for this template template argument available. +#define BOOST_TYPEOF_DEFINE_TEMPLATE_TEMPLATE_ARGUMENT(r,data,elem)\ + template\ + struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME(encode_template,BOOST_TYPEOF_MAKE_OBJ(elem)); + +//This typedef is used inside decode_type_impl as a replacement for typedef Name type; +#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_TYPE(Name,Params,ID)\ + typename BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(decode_template,Params) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) >::type + + +#define BOOST_TYPEOF_REGISTER_COMPACT_TEMPLATE_PARAM_PAIR(z,n,elem)\ + BOOST_TYPEOF_COMPACT_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(P, n) + +#endif //BOOST_TYPEOF_COMPLIANT_REGISTER_TEMPLATE_TEMPLATE_HPP_INCLUDED \ No newline at end of file diff --git a/include/boost/typeof/compliant/template_encoding.hpp b/include/boost/typeof/compliant/template_encoding.hpp index 4859ba9..fca53a4 100755 --- a/include/boost/typeof/compliant/template_encoding.hpp +++ b/include/boost/typeof/compliant/template_encoding.hpp @@ -1,4 +1,5 @@ // Copyright (C) 2004 Arkadiy Vertleyb +// Copyright (C) 2005 Peder Holt // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) @@ -8,6 +9,7 @@ #include #include #include +#include ////////// @@ -46,18 +48,23 @@ #define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\ BOOST_TYPEOF_PARAM_DECODE(BOOST_TYPEOF_MAKE_OBJ(elem))(BOOST_TYPEOF_MAKE_OBJ(elem), n) -#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(r, data, n, elem)\ - , BOOST_TYPEOF_PARAM_GETTYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(P, n) +#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z,n,elem) \ + BOOST_TYPEOF_EXPAND_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) BOOST_PP_CAT(P, n) + +//Branch the final typedef between the 'normal' typedef and template template typedef +#define BOOST_TYPEOF_REGISTER_TEMPLATE_TYPEDEF_TYPE(Name,Params,ID)\ + BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATE_TEMPLATE_ARGUMENTS(Params),\ + BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_TYPE,\ + BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE\ + )(Name,Params,ID) + +#define BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\ + Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) > -// #define BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, ID)\ - namespace boost{namespace type_of{namespace{\ template\ struct encode_type_impl type;\ + typedef BOOST_TYPEOF_REGISTER_TEMPLATE_TYPEDEF_TYPE(Name,Params,ID) type;\ typedef BOOST_PP_CAT(iter, BOOST_PP_SEQ_SIZE(Params)) iter;\ - };\ - }}} + }; #define BOOST_TYPEOF_REGISTER_TEMPLATE_X(Name, Params)\ - BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, BOOST_TYPEOF_UNIQUE_ID()) + namespace boost{namespace type_of{namespace{\ + BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,BOOST_TYPEOF_UNIQUE_ID())\ + BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, BOOST_TYPEOF_UNIQUE_ID())\ + }}} + +#define BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS_X(Name, Params)\ + namespace boost{namespace type_of{namespace{\ + BOOST_TYPEOF_REGISTER_ARGUMENTS_FOR_TT_ENCODING(Name,Params,BOOST_TYPEOF_UNIQUE_ID())\ + BOOST_TYPEOF_REGISTER_TEMPLATE_X_IMPL(Name, Params, BOOST_TYPEOF_UNIQUE_ID())\ + }}} #endif//BOOST_TYPEOF_COMPLIANT_TEMPLATE_ENCODING_HPP_INCLUDED diff --git a/include/boost/typeof/register_integral.hpp b/include/boost/typeof/register_integral.hpp index afb3bc1..3179e5e 100644 --- a/include/boost/typeof/register_integral.hpp +++ b/include/boost/typeof/register_integral.hpp @@ -1,4 +1,5 @@ // Copyright (C) 2004 Arkadiy Vertleyb +// Copyright (C) 2005 Peder Holt // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) @@ -41,22 +42,22 @@ #define BOOST_TYPEOF_MAKE_OBJ_class BOOST_TYPEOF_TYPE_PARAM #define BOOST_TYPEOF_MAKE_OBJ_typename BOOST_TYPEOF_TYPE_PARAM -#define BOOST_TYPEOF_MAKE_OBJ_char BOOST_TYPEOF_INTEGRAL_PARAM(char) -#define BOOST_TYPEOF_MAKE_OBJ_short BOOST_TYPEOF_INTEGRAL_PARAM(short) -#define BOOST_TYPEOF_MAKE_OBJ_int BOOST_TYPEOF_INTEGRAL_PARAM(int) -#define BOOST_TYPEOF_MAKE_OBJ_long BOOST_TYPEOF_INTEGRAL_PARAM(long) -#define BOOST_TYPEOF_MAKE_OBJ_bool BOOST_TYPEOF_INTEGRAL_PARAM(bool) -#define BOOST_TYPEOF_MAKE_OBJ_unsigned BOOST_TYPEOF_INTEGRAL_PARAM(unsigned) -#define BOOST_TYPEOF_MAKE_OBJ_size_t BOOST_TYPEOF_INTEGRAL_PARAM(size_t) -#define BOOST_TYPEOF_MAKE_OBJ_unsignedchar BOOST_TYPEOF_INTEGRAL_PARAM(unsigned char) -#define BOOST_TYPEOF_MAKE_OBJ_unsignedshort BOOST_TYPEOF_INTEGRAL_PARAM(unsigned short) -#define BOOST_TYPEOF_MAKE_OBJ_unsignedint BOOST_TYPEOF_INTEGRAL_PARAM(unsigned int) -#define BOOST_TYPEOF_MAKE_OBJ_unsignedlong BOOST_TYPEOF_INTEGRAL_PARAM(unsigned long) -#define BOOST_TYPEOF_MAKE_OBJ_signedchar BOOST_TYPEOF_INTEGRAL_PARAM(signed char) -#define BOOST_TYPEOF_MAKE_OBJ_signedshort BOOST_TYPEOF_INTEGRAL_PARAM(signed short) -#define BOOST_TYPEOF_MAKE_OBJ_signedint BOOST_TYPEOF_INTEGRAL_PARAM(signed int) -#define BOOST_TYPEOF_MAKE_OBJ_signedlong BOOST_TYPEOF_INTEGRAL_PARAM(signed long) -#define BOOST_TYPEOF_MAKE_OBJ_integral(x) BOOST_TYPEOF_INTEGRAL_PARAM(x) +#define BOOST_TYPEOF_MAKE_OBJ_char BOOST_TYPEOF_INTEGRAL_PARAM(char,char) +#define BOOST_TYPEOF_MAKE_OBJ_short BOOST_TYPEOF_INTEGRAL_PARAM(short,short) +#define BOOST_TYPEOF_MAKE_OBJ_int BOOST_TYPEOF_INTEGRAL_PARAM(int,int) +#define BOOST_TYPEOF_MAKE_OBJ_long BOOST_TYPEOF_INTEGRAL_PARAM(long,long) +#define BOOST_TYPEOF_MAKE_OBJ_bool BOOST_TYPEOF_INTEGRAL_PARAM(bool,bool) +#define BOOST_TYPEOF_MAKE_OBJ_unsigned BOOST_TYPEOF_INTEGRAL_PARAM(unsigned,uint) +#define BOOST_TYPEOF_MAKE_OBJ_size_t BOOST_TYPEOF_INTEGRAL_PARAM(size_t,size_t) +#define BOOST_TYPEOF_MAKE_OBJ_unsignedchar BOOST_TYPEOF_INTEGRAL_PARAM(unsigned char,uchar) +#define BOOST_TYPEOF_MAKE_OBJ_unsignedshort BOOST_TYPEOF_INTEGRAL_PARAM(unsigned short,ushort) +#define BOOST_TYPEOF_MAKE_OBJ_unsignedint BOOST_TYPEOF_INTEGRAL_PARAM(unsigned int,uint) +#define BOOST_TYPEOF_MAKE_OBJ_unsignedlong BOOST_TYPEOF_INTEGRAL_PARAM(unsigned long,ulong) +#define BOOST_TYPEOF_MAKE_OBJ_signedchar BOOST_TYPEOF_INTEGRAL_PARAM(signed char,schar) +#define BOOST_TYPEOF_MAKE_OBJ_signedshort BOOST_TYPEOF_INTEGRAL_PARAM(signed short,short) +#define BOOST_TYPEOF_MAKE_OBJ_signedint BOOST_TYPEOF_INTEGRAL_PARAM(signed int,int) +#define BOOST_TYPEOF_MAKE_OBJ_signedlong BOOST_TYPEOF_INTEGRAL_PARAM(signed long,long) +#define BOOST_TYPEOF_MAKE_OBJ_integral(x) BOOST_TYPEOF_EXPLICIT_INTEGRAL_PARAM(x) #define BOOST_TYPEOF_INTEGRAL(X) integral(X) BOOST_TYPEOF_EAT #define BOOST_TYPEOF_EAT_BOOST_TYPEOF @@ -73,14 +74,43 @@ #define BOOST_TYPEOF_PARAM_GETTYPE(Param)\ BOOST_PP_SEQ_ELEM(1, Param) +#define BOOST_TYPEOF_PARAM_GETNAME(Param)\ + BOOST_PP_SEQ_ELEM(2, Param) + // "constructors" #define BOOST_TYPEOF_TYPE_PARAM\ (TYPE_PARAM)\ + (class)\ (class) -#define BOOST_TYPEOF_INTEGRAL_PARAM(Type)\ +#define BOOST_TYPEOF_INTEGRAL_PARAM(Type,Name)\ (INTEGRAL_PARAM)\ - (Type) + (Type)\ + (Name) + +#define BOOST_TYPEOF_EXPLICIT_INTEGRAL_PARAM(Type)\ + (EXPLICIT_INTEGRAL_PARAM)\ + (Type)\ + (BOOST_PP_CAT(_,Type)) + +#define BOOST_TYPEOF_DECODE_EXPLICIT_INTEGRAL_PARAM BOOST_TYPEOF_DECODE_INTEGRAL_PARAM +#define BOOST_TYPEOF_ENCODE_EXPLICIT_INTEGRAL_PARAM BOOST_TYPEOF_ENCODE_INTEGRAL_PARAM + +#define BOOST_TYPEOF_EXPAND_TYPE(Param)\ + BOOST_PP_CAT(BOOST_TYPEOF_EXPAND_, BOOST_PP_SEQ_ELEM(0, Param))(Param) + +#define BOOST_TYPEOF_EXPAND_TYPE_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) +#define BOOST_TYPEOF_EXPAND_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) +#define BOOST_TYPEOF_EXPAND_EXPLICIT_INTEGRAL_PARAM(Param) BOOST_TYPEOF_PARAM_GETTYPE(Param) + +#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)) #endif//BOOST_TYPEOF_COMPLIANT_TEMPLATE_ENCODING_HPP_INCLUDED diff --git a/include/boost/typeof/std/deque.hpp b/include/boost/typeof/std/deque.hpp index d264bd1..7942816 100755 --- a/include/boost/typeof/std/deque.hpp +++ b/include/boost/typeof/std/deque.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::deque, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::deque, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::deque, 2) #endif//BOOST_TYPEOF_STD_deque_hpp_INCLUDED diff --git a/include/boost/typeof/std/fstream.hpp b/include/boost/typeof/std/fstream.hpp index cfa056f..b3e7c2f 100755 --- a/include/boost/typeof/std/fstream.hpp +++ b/include/boost/typeof/std/fstream.hpp @@ -13,21 +13,13 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_filebuf, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_filebuf, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_filebuf, 2) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ifstream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ifstream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ifstream, 2) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ofstream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ofstream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ofstream, 2) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_fstream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_fstream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_fstream, 2) #ifdef BOOST_TYPEOF_COMPLIANT BOOST_TYPEOF_REGISTER_TYPE(std::filebuf) diff --git a/include/boost/typeof/std/iostream.hpp b/include/boost/typeof/std/iostream.hpp index 762d6f9..2331ec7 100755 --- a/include/boost/typeof/std/iostream.hpp +++ b/include/boost/typeof/std/iostream.hpp @@ -14,9 +14,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() BOOST_TYPEOF_REGISTER_TEMPLATE(std::fpos, 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ios, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ios, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ios, 2) #endif//BOOST_TYPEOF_STD_iostream_hpp_INCLUDED diff --git a/include/boost/typeof/std/istream.hpp b/include/boost/typeof/std/istream.hpp index 431e058..0b14fd1 100755 --- a/include/boost/typeof/std/istream.hpp +++ b/include/boost/typeof/std/istream.hpp @@ -13,13 +13,9 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_istream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istream, 2) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_iostream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_iostream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_iostream, 2) #ifdef BOOST_TYPEOF_COMPLIANT BOOST_TYPEOF_REGISTER_TYPE(std::istream) diff --git a/include/boost/typeof/std/iterator.hpp b/include/boost/typeof/std/iterator.hpp index 12fa823..1b7e17a 100755 --- a/include/boost/typeof/std/iterator.hpp +++ b/include/boost/typeof/std/iterator.hpp @@ -15,16 +15,12 @@ BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator_traits, 1) #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::iterator, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 3) #else -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 2) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 3) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 4) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::iterator, 2) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::iterator, 3) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::iterator, 4) BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 5) #endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) BOOST_TYPEOF_REGISTER_TYPE(std::input_iterator_tag) @@ -33,11 +29,9 @@ BOOST_TYPEOF_REGISTER_TYPE(std::forward_iterator_tag) BOOST_TYPEOF_REGISTER_TYPE(std::bidirectional_iterator_tag) BOOST_TYPEOF_REGISTER_TYPE(std::random_access_iterator_tag) #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 2) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 3) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 4) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::reverse_iterator, 2) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::reverse_iterator, 3) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::reverse_iterator, 4) BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 5) #else BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 1) @@ -46,31 +40,21 @@ BOOST_TYPEOF_REGISTER_TEMPLATE(std::back_insert_iterator, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::front_insert_iterator, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::insert_iterator, 1) #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istream_iterator, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istream_iterator, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 3) #else -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 2) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 3) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istream_iterator, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istream_iterator, 2) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istream_iterator, 3) BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 4) #endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::ostream_iterator, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::ostream_iterator, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 3) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::istreambuf_iterator, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::istreambuf_iterator, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::istreambuf_iterator, 2) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostreambuf_iterator, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::ostreambuf_iterator, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostreambuf_iterator, 2) #endif//BOOST_TYPEOF_STD_iterator_hpp_INCLUDED diff --git a/include/boost/typeof/std/list.hpp b/include/boost/typeof/std/list.hpp index 991bdf5..65f1be8 100755 --- a/include/boost/typeof/std/list.hpp +++ b/include/boost/typeof/std/list.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::list, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::list, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::list, 2) #endif//BOOST_TYPEOF_STD_list_hpp_INCLUDED diff --git a/include/boost/typeof/std/map.hpp b/include/boost/typeof/std/map.hpp index 616ac46..db6f1e7 100755 --- a/include/boost/typeof/std/map.hpp +++ b/include/boost/typeof/std/map.hpp @@ -15,15 +15,11 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 2) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 3) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::map, 2) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::map, 3) BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 4) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 2) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 3) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::multimap, 2) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::multimap, 3) BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 4) #endif//BOOST_TYPEOF_STD_map_hpp_INCLUDED diff --git a/include/boost/typeof/std/ostream.hpp b/include/boost/typeof/std/ostream.hpp index d8c20c7..d4bcc18 100755 --- a/include/boost/typeof/std/ostream.hpp +++ b/include/boost/typeof/std/ostream.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostream, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ostream, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostream, 2) #ifdef BOOST_TYPEOF_COMPLIANT BOOST_TYPEOF_REGISTER_TYPE(std::ostream) diff --git a/include/boost/typeof/std/queue.hpp b/include/boost/typeof/std/queue.hpp index 6681a57..580ce99 100755 --- a/include/boost/typeof/std/queue.hpp +++ b/include/boost/typeof/std/queue.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::queue, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::queue, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::queue, 2) #endif//BOOST_TYPEOF_STD_queue_hpp_INCLUDED diff --git a/include/boost/typeof/std/set.hpp b/include/boost/typeof/std/set.hpp index 16c0665..8e5af18 100755 --- a/include/boost/typeof/std/set.hpp +++ b/include/boost/typeof/std/set.hpp @@ -14,15 +14,11 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::set, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::set, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 3) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::multiset, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::multiset, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 3) #endif//BOOST_TYPEOF_STD_set_hpp_INCLUDED diff --git a/include/boost/typeof/std/sstream.hpp b/include/boost/typeof/std/sstream.hpp index 4d63503..43a73cb 100755 --- a/include/boost/typeof/std/sstream.hpp +++ b/include/boost/typeof/std/sstream.hpp @@ -14,25 +14,17 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_stringbuf, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_stringbuf, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 3) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_istringstream, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_istringstream, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 3) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ostringstream, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_ostringstream, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 3) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_stringstream, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_stringstream, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 3) #ifdef BOOST_TYPEOF_COMPLIANT BOOST_TYPEOF_REGISTER_TYPE(std::stringbuf) diff --git a/include/boost/typeof/std/stack.hpp b/include/boost/typeof/std/stack.hpp index 9414ef3..13b93dc 100755 --- a/include/boost/typeof/std/stack.hpp +++ b/include/boost/typeof/std/stack.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::stack, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::stack, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::stack, 2) #endif//BOOST_TYPEOF_STD_stack_hpp_INCLUDED diff --git a/include/boost/typeof/std/streambuf.hpp b/include/boost/typeof/std/streambuf.hpp index 815da33..56df27e 100755 --- a/include/boost/typeof/std/streambuf.hpp +++ b/include/boost/typeof/std/streambuf.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_streambuf, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_streambuf, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_streambuf, 2) #endif//BOOST_TYPEOF_STD_streambuf_hpp_INCLUDED diff --git a/include/boost/typeof/std/string.hpp b/include/boost/typeof/std/string.hpp index d7b70ed..7a67f76 100755 --- a/include/boost/typeof/std/string.hpp +++ b/include/boost/typeof/std/string.hpp @@ -14,10 +14,8 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() BOOST_TYPEOF_REGISTER_TEMPLATE(std::char_traits, 1) -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 1) -BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 2) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_string, 1) +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::basic_string, 2) BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 3) #ifdef BOOST_TYPEOF_COMPLIANT BOOST_TYPEOF_REGISTER_TYPE(std::string) diff --git a/include/boost/typeof/std/vector.hpp b/include/boost/typeof/std/vector.hpp index d650532..2a88500 100755 --- a/include/boost/typeof/std/vector.hpp +++ b/include/boost/typeof/std/vector.hpp @@ -13,9 +13,7 @@ #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() -#ifdef BOOST_TYPEOF_COMPLIANT -BOOST_TYPEOF_REGISTER_TEMPLATE(std::vector, 1) -#endif//BOOST_TYPEOF_COMPLIANT +BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(std::vector, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(std::vector, 2) #endif//BOOST_TYPEOF_STD_vector_hpp_INCLUDED diff --git a/include/boost/typeof/typeof.hpp b/include/boost/typeof/typeof.hpp index ae60b0d..e5a4778 100755 --- a/include/boost/typeof/typeof.hpp +++ b/include/boost/typeof/typeof.hpp @@ -60,6 +60,11 @@ BOOST_PP_REPEAT(n, BOOST_TYPEOF_REGISTER_TEMPLATE_TYPE_PARAM_, ~)\ ) +#define BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS(Name, n)\ + BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS_X(Name,\ + BOOST_PP_REPEAT(n, BOOST_TYPEOF_REGISTER_TEMPLATE_TYPE_PARAM_, ~)\ + ) + #define BOOST_TYPEOF_UNIQUE_ID()\ BOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__ diff --git a/include/boost/typeof/vintage/template_encoding.hpp b/include/boost/typeof/vintage/template_encoding.hpp index f87c795..f04e19e 100644 --- a/include/boost/typeof/vintage/template_encoding.hpp +++ b/include/boost/typeof/vintage/template_encoding.hpp @@ -52,6 +52,9 @@ #define BOOST_TYPEOF_CAST_INTEGRAL_PARAM(This, n)\ BOOST_TYPEOF_PARAM_GETTYPE(This)(BOOST_PP_CAT(P,n)) +#define BOOST_TYPEOF_CAST_EXPLICIT_INTEGRAL_PARAM(This, n)\ + BOOST_TYPEOF_PARAM_GETTYPE(This)(BOOST_PP_CAT(P,n)) + // #define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\ @@ -112,4 +115,6 @@ namespace boost { namespace type_of{\ BOOST_TYPEOF_DECODE_TEMPLATE_X_IMPL(template_type,seq,BOOST_TYPEOF_UNIQUE_ID())\ }}//namespace boost::type_of +#define BOOST_TYPEOF_REGISTER_TEMPLATE_WITH_DEFAULTS_X(Name, Params) + #endif //BOOST_VINTAGE_TEMPLATE_ENCODING_HPP_INCLUDED diff --git a/test/main.cpp b/test/main.cpp index b1d4879..a8ac194 100755 --- a/test/main.cpp +++ b/test/main.cpp @@ -99,6 +99,22 @@ BOOST_TYPEOF_REGISTER_TEMPLATE_X(with_integrals, BOOST_STATIC_ASSERT((typeof_test >::value)); BOOST_STATIC_ASSERT((typeof_test >::value)); +#ifdef BOOST_TYPEOF_COMPLIANT +#pragma message("template template encoding...") + +namespace template_template { + template class P0,int P1> + struct tt_test {}; + + template + struct C {}; +} + +BOOST_TYPEOF_REGISTER_TEMPLATE_X(template_template::tt_test,(BOOST_TYPEOF_TEMPLATE( (typename)(unsigned int) ))(int)) +BOOST_TYPEOF_REGISTER_TEMPLATE_X(template_template::C,(typename)(unsigned int)) +BOOST_STATIC_ASSERT((typeof_test >::value)); +#endif + #pragma message("namespace-level function pointers...") BOOST_STATIC_ASSERT(typeof_test::value); BOOST_STATIC_ASSERT(typeof_test::value);