Implemented support for template template arguments.

[SVN r2469]
2005-01-27 20:52:10 +00:00
parent ef69402869
commit 634d010810
22 changed files with 346 additions and 147 deletions
--- 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")
        {
--- a/include/boost/typeof/compliant/register_template_template.hpp
+++ 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 <boost/preprocessor/comparison/equal.hpp>
+#include <boost/preprocessor/comparison/not_equal.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+
+namespace boost{namespace type_of {namespace {
+    template<class T,class Iter>
+    struct decode_template_impl;
+
+    template<class Iter> struct decode_template
+        : decode_template_impl<typename mpl::deref<Iter>::type, typename mpl::next<Iter>::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 <typename,typename> class.
+#define BOOST_TYPEOF_EXPAND_TEMPLATE_PARAM(Param)\
+    template<BOOST_TYPEOF_EXPAND_TEMPLATE_PARAM_IMPL(BOOST_TYPEOF_PARAM_GETTYPE(Param))> 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_...<boost::mpl::vector0,Pn>.
+#define BOOST_TYPEOF_WRAPPED_TEMPLATE_PARAM(n,Param) BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME(encode_template,Param)<boost::mpl::vector0<>,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<typename V,BOOST_TYPEOF_EXPAND_TYPE(BOOST_TYPEOF_TEMPLATE_PARAM(Params)) T>\
+    struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(encode_template,Params);\
+    template<typename V>\
+    struct BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(encode_template,Params)<V,Name>\
+    : BOOST_TYPEOF_PUSH_BACK<V, mpl::size_t<ID> >\
+    {};\
+    template<class Iter> struct decode_template_impl<mpl::size_t<ID>, 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<typename T\
+        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_COMPACT_TEMPLATE_PARAM_PAIR)\
+    >\
+    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<ID> 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<typename V,BOOST_TYPEOF_EXPAND_TYPE(BOOST_TYPEOF_MAKE_OBJ(elem)) T>\
+    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<P0,P1,...PN> type;
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_TYPE(Name,Params,ID)\
+    typename BOOST_TYPEOF_TEMPLATE_TEMPLATE_NAME_IMPL(decode_template,Params)<boost::mpl::size_t<ID> 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
--- 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 <boost/typeof/compliant/encode_decode.hpp>
 #include <boost/typeof/compliant/int_encoding.hpp>
 #include <boost/typeof/register_integral.hpp>
+#include <boost/typeof/compliant/register_template_template.hpp>

 //////////

@@ -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<class V\
-        BOOST_PP_SEQ_FOR_EACH_I(\
-            BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR,\
-            ~,\
-            Params)\
+        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
    >\
    struct encode_type_impl<V, Name<\
        BOOST_PP_ENUM_PARAMS(\
@@ -79,12 +86,20 @@
            BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM,\
            ~,\
            Params)\
-        typedef Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) > 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
--- 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
--- 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
--- 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)
--- 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
--- 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)
--- 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
--- 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
--- 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
--- 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)
--- 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
--- 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
--- 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)
--- 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
--- 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
--- 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)
--- 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
--- 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__

--- 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
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -99,6 +99,22 @@ BOOST_TYPEOF_REGISTER_TEMPLATE_X(with_integrals,
 BOOST_STATIC_ASSERT((typeof_test<with_integrals<int, 5, 4, -3, 2, true, false, -1, 5> >::value));
 BOOST_STATIC_ASSERT((typeof_test<with_integrals<int, 1, 1, 0, ULONG_MAX, false, true, -1, 0> >::value));

+#ifdef BOOST_TYPEOF_COMPLIANT
+#pragma message("template template encoding...")
+
+namespace template_template {
+    template<template<typename,unsigned int> class P0,int P1>
+    struct tt_test {};
+
+    template<typename A,unsigned int B> 
+    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<template_template::tt_test<template_template::C,4> >::value));
+#endif 
+
 #pragma message("namespace-level function pointers...")
 BOOST_STATIC_ASSERT(typeof_test<double(*)()>::value);
 BOOST_STATIC_ASSERT(typeof_test<double(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);