Release 1.37.0

[SVN r49549]

include/boost/typeof/msvc/typeof_impl.hpp

@@ -153,7 +153,58 @@ namespace boost
             };
         };
 # endif
+# if BOOST_WORKAROUND(BOOST_MSVC,==1310)
+        template<const std::type_info& ref_type_info>
+        struct msvc_typeid_wrapper {
+            typedef typename msvc_extract_type<msvc_typeid_wrapper>::id2type id2type;
+            typedef typename id2type::type wrapped_type;
+            typedef typename wrapped_type::type type;
+        };
+        //This class is used for registering the type T. encode_type<T> is mapped against typeid(encode_type<T>).
+        //msvc_typeid_wrapper<typeid(encode_type<T>)> will now have a type typedef that equals encode_type<T>.
+        template<typename T>
+        struct encode_type
+        {
+            typedef encode_type<T> input_type;
+            //Invoke registration of encode_type<T>. typeid(encode_type<T>) is now mapped to encode_type<T>. Do not use registered_type for anything.
+            //The reason for registering encode_type<T> rather than T, is that VC handles typeid(function reference) poorly. By adding another
+            //level of indirection, we solve this problem.
+            typedef typename msvc_register_type<input_type,msvc_typeid_wrapper<typeid(input_type)> >::id2type registered_type;
+            typedef T type;
+        };
 
+        template<typename T> typename disable_if<
+            typename is_function<T>::type,
+            typename encode_type<T>::input_type>::type encode_start(T const&);
+
+        template<typename T> typename enable_if<
+            typename is_function<T>::type,
+            typename encode_type<T>::input_type>::type encode_start(T&);
+
+        template<typename Organizer, typename T>
+        msvc_register_type<T,Organizer> typeof_register_type(const T&);
+
+
+# define BOOST_TYPEOF(expr) \
+    boost::type_of::msvc_typeid_wrapper<typeid(boost::type_of::encode_start(expr))>::type
+
+# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
+
+# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
+struct name {\
+    enum {_typeof_register_value=sizeof(typeid(boost::type_of::typeof_register_type<name>(expr)))};\
+    typedef typename boost::type_of::msvc_extract_type<name>::id2type id2type;\
+    typedef typename id2type::type type;\
+};
+
+# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
+struct name {\
+    enum {_typeof_register_value=sizeof(typeid(boost::type_of::typeof_register_type<name>(expr)))};\
+    typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\
+    typedef id2type::type type;\
+};
+
+# else
         template<int ID>
         struct msvc_typeid_wrapper {
             typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
@@ -211,18 +262,19 @@ namespace boost
 
 # define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
     struct name {\
-        enum {_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr))};\
+        BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
         typedef typename boost::type_of::msvc_extract_type<name>::id2type id2type;\
         typedef typename id2type::type type;\
     };
 
 # define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
     struct name {\
-        enum {_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr))};\
+        BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
         typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\
         typedef id2type::type type;\
     };
 
+#endif
     }
 }
 

include/boost/typeof/register_functions.hpp

@@ -24,19 +24,12 @@
 enum 
 {
     FUN_ID                          = BOOST_TYPEOF_UNIQUE_ID(),
-    FUN_PTR_ID                      = FUN_ID +  1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    FUN_REF_ID                      = FUN_ID +  2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    MEM_FUN_ID                      = FUN_ID +  3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    CONST_MEM_FUN_ID                = FUN_ID +  4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_MEM_FUN_ID             = FUN_ID +  5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_CONST_MEM_FUN_ID       = FUN_ID +  6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    FUN_VAR_ID                      = FUN_ID +  7 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    FUN_VAR_PTR_ID                  = FUN_ID +  8 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    FUN_VAR_REF_ID                  = FUN_ID +  9 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    MEM_FUN_VAR_ID                  = FUN_ID + 10 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    CONST_MEM_FUN_VAR_ID            = FUN_ID + 11 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_MEM_FUN_VAR_ID         = FUN_ID + 12 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_CONST_MEM_FUN_VAR_ID   = FUN_ID + 13 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+    FUN_PTR_ID                      = FUN_ID + 1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_REF_ID                      = FUN_ID + 2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    MEM_FUN_ID                      = FUN_ID + 3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    CONST_MEM_FUN_ID                = FUN_ID + 4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_MEM_FUN_ID             = FUN_ID + 5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_CONST_MEM_FUN_ID       = FUN_ID + 6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
 };
 
 BOOST_TYPEOF_BEGIN_ENCODE_NS

include/boost/typeof/register_functions_iterate.hpp

@@ -15,13 +15,6 @@ struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P))>
     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::mpl::size_t<FUN_PTR_ID + n>, Iter>
 {
@@ -31,15 +24,6 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
     typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
 };
 
-template<class Iter>
-struct decode_type_impl<boost::mpl::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
@@ -51,13 +35,6 @@ struct decode_type_impl<boost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
         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::mpl::size_t<FUN_REF_ID + n>, Iter>
     {
@@ -67,15 +44,6 @@ struct decode_type_impl<boost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
         typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
     };
 
-    template<class Iter>
-    struct decode_type_impl<boost::mpl::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)>
@@ -85,13 +53,6 @@ struct decode_type_impl<boost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
         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::mpl::size_t<FUN_ID + n>, Iter>
     {
@@ -101,15 +62,6 @@ struct decode_type_impl<boost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
         typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
     };
 
-    template<class Iter>
-    struct decode_type_impl<boost::mpl::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

index.html

@@ -10,7 +10,7 @@ License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../doc/html/typeof.html">../../doc/html/typeof.html</a>
+<a href="../../doc/html/xpressive.html">../../doc/html/typeof.html</a>
 </body>
 </html>
 

test/function.cpp

@@ -6,5 +6,3 @@
 
 BOOST_STATIC_ASSERT(boost::type_of::test<void()>::value);
 BOOST_STATIC_ASSERT(boost::type_of::test<double(bool)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<float(int, ...)>::value);

test/function_binding.cpp

@@ -7,16 +7,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/static_assert.hpp>
 
-int foo1(double);
-int foo2(...);
-int foo3(int, ...);
-typedef int(&FREF1)(double);
-typedef int(&FREF2)(...);
-typedef int(&FREF3)(int, ...);
-FREF1 fref1 = *foo1;
-FREF2 fref2 = *foo2;
-FREF3 fref3 = *foo3;
+int foo(double);
+typedef int(&FREF)(double);
+FREF fref = *foo;
 
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref1), int(double)>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref2), int(...)>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref3), int(int,...)>::value));
+BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref), int(double)>::value));

test/function_ptr.cpp

@@ -8,19 +8,12 @@ BOOST_STATIC_ASSERT(boost::type_of::test<double(*)()>::value);
 BOOST_STATIC_ASSERT(boost::type_of::test<double(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);
 BOOST_STATIC_ASSERT(boost::type_of::test<void(*)()>::value);
 BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(int, double, short, char*, bool, char, float, long, unsigned short, ...)>::value);
 
 // check that const gets stripped from function pointer
 
-int foo1(double);
-int foo2(...);
-typedef int(*PTR1)(double);
-typedef int(*PTR2)(...);
-typedef const PTR1 CPTR1;
-typedef const PTR2 CPTR2;
-CPTR1 cptr1 = foo1;
-CPTR2 cptr2 = foo2;
+int foo(double);
+typedef int(*PTR)(double);
+typedef const PTR CPTR;
+CPTR cptr = foo;
 
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(cptr1), PTR1>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(cptr2), PTR2>::value));
+BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(cptr), PTR>::value));

test/function_ptr_from_tpl.cpp

@@ -6,23 +6,15 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/static_assert.hpp>
 
-void f1() {}
-void f2(...) {}
+void f()
+{}
 
 template<class T> 
-struct tpl1
+struct tpl
 {
-    typedef BOOST_TYPEOF_TPL(&f1) type;
+    typedef BOOST_TYPEOF_TPL(&f) type;
 };
 
-template<class T> 
-struct tpl2
-{
-    typedef BOOST_TYPEOF_TPL(&f2) type;
-};
-
-typedef void(*fun1_type)();
-typedef void(*fun2_type)(...);
+typedef void(*fun_type)();
  
-BOOST_STATIC_ASSERT((boost::is_same<tpl1<void>::type, fun1_type>::value));
-BOOST_STATIC_ASSERT((boost::is_same<tpl2<void>::type, fun2_type>::value));
+BOOST_STATIC_ASSERT((boost::is_same<tpl<void>::type, fun_type>::value));

test/function_ref.cpp

@@ -6,5 +6,3 @@
 
 BOOST_STATIC_ASSERT(boost::type_of::test<void(&)()>::value);
 BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(int, short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(int,...)>::value);

tools/preprocess.pl

@@ -1,7 +1,7 @@
 # // (C) Copyright Tobias Schwinger
 # //
 # // Use modification and distribution are subject to the boost Software License
-# // Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+# // Version 1.0. (See http:/\/www.boost.org/LICENSE_1_0.txt).
 
 # // Preprocess and run this script.
 # //