to_string fixes

[SVN r44164]

include/boost/exception/detail/is_output_streamable.hpp

@@ -0,0 +1,50 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_898984B4076411DD973EDFA055D89593
+#define UUID_898984B4076411DD973EDFA055D89593
+
+#include <ostream>
+
+namespace
+boost
+    {
+	namespace
+	exception_detail
+		{
+		template <bool>
+		struct
+		is_output_streamable_dispatch
+			{
+			enum e { value=1 };
+			};
+
+		template <>
+		struct
+		is_output_streamable_dispatch<false>
+			{
+			enum e { value=0 };
+			};
+
+        template <class T,class CharT,class Traits>
+        char operator<<( std::basic_ostream<CharT,Traits> &, T const & );
+
+		template <class T,class CharT,class Traits>
+        struct
+		is_output_streamable_impl
+			{
+			enum e { value=is_output_streamable_dispatch<1!=sizeof((*(std::basic_ostream<CharT,Traits>*)0)<<(*(T*)0))>::value };
+			};
+		}
+
+	template <class T, class CharT=char, class Traits=std::char_traits<CharT> >
+    struct
+	is_output_streamable
+		{
+		enum e { value=exception_detail::is_output_streamable_impl<T,CharT,Traits>::value };
+		};
+    }
+
+#endif

include/boost/exception/to_string.hpp

@@ -6,22 +6,62 @@
 #ifndef UUID_7E48761AD92811DC9011477D56D89593
 #define UUID_7E48761AD92811DC9011477D56D89593
 
+#include <boost/utility/enable_if.hpp>
+#include <boost/exception/detail/is_output_streamable.hpp>
 #include <sstream>
-#include <string>
 
 namespace
 boost
     {
-    namespace
+	namespace
-        {
+	exception_detail
+		{
+		template <bool>
+		struct
+		has_to_string_dispatch
+			{
+			enum e { value=1 };
+			};
+
+		template <>
+		struct
+		has_to_string_dispatch<false>
+			{
+			enum e { value=0 };
+			};
+
+		template <class T>
+		std::string
+		to_string( T const & x, typename enable_if< is_output_streamable<T> >::type * = 0 )
+			{
+			std::ostringstream out;
+			out << x;
+			return out.str();
+			}
+
         template <class T>
-        std::string
+        char to_string( T const &, typename disable_if< is_output_streamable<T> >::type * = 0 );
-        to_string( T const & x )
+
-            {
+		template <class T>
-            std::ostringstream out;
+        struct
-            out << x;
+		has_to_string_impl
-            return out.str();
+			{
-            }
+			enum e { value=has_to_string_dispatch<1!=sizeof(to_string(*(T*)0))>::value };
+			};
+		}
+
+	template <class T>
+    struct
+	has_to_string
+		{
+		enum e { value=exception_detail::has_to_string_impl<T>::value };
+		};
+
+	template <class T>
+    std::string
+	to_string( T const & x, typename enable_if< is_output_streamable<T> >::type * = 0 )
+        {
+		return exception_detail::to_string(x);
         }
     }
 

include/boost/exception/to_string_stub.hpp

@@ -13,53 +13,6 @@
 namespace
 boost
     {
-    namespace
-    exception_detail
-        {
-        template <bool ShiftLeftAvailable>
-        struct shift_left_dispatcher;
-
-        template <>
-        struct
-        shift_left_dispatcher<true>
-            {
-            template <class T,class CharT,class Traits,class Stub>
-            static
-            void
-            convert( std::basic_ostream<CharT,Traits> & out, T const & x, Stub )
-                {
-                out << x;
-                }
-            };
-
-        template <>
-        struct
-        shift_left_dispatcher<false>
-            {
-            template <class T,class CharT,class Traits,class Stub>
-            static
-            void
-            convert( std::basic_ostream<CharT,Traits> & out, T const & x, Stub s )
-                {
-                out << s(x);
-                }
-            };
-
-        namespace
-        shift_left_dispatch
-            {
-            template <class T,class CharT,class Traits>
-            char operator<<( std::basic_ostream<CharT,Traits> &, T );
-
-            template <class T,class CharT,class Traits,class Stub>
-            void
-            dispatch( std::basic_ostream<CharT,Traits> & out, T const & x, Stub s )
-                {
-                shift_left_dispatcher<1!=sizeof(out<<x)>::convert(out,x,s);
-                }
-            }
-        }
-
     namespace
     exception_detail
         {
@@ -82,26 +35,21 @@ boost
             {
             template <class T,class Stub>
             static
-            std::string
+			std::string
             convert( T const & x, Stub s )
                 {
-                std::ostringstream out;
+                return s(x);
-                shift_left_dispatch::dispatch(out,x,s);
-                return out.str();
                 }
             };
 
         namespace
         to_string_dispatch
             {
-            template <class T>
-            char to_string( T );
-
             template <class T,class Stub>
             std::string
             dispatch( T const & x, Stub s )
                 {
-                return to_string_dispatcher<1!=sizeof(to_string(x))>::convert(x,s);
+				return to_string_dispatcher<has_to_string<T>::value>::convert(x,s);
                 }
             }
 

test/Jamfile.v2

@@ -7,9 +7,15 @@
 
 import testing ;
 
+#to_string
+run is_output_streamable_test.cpp ;
+run to_string_test.cpp ;
+run to_string_stub_test.cpp ;
+compile-fail to_string_fail.cpp ;
+
+#exception
 run cloning_test.cpp ;
 run unknown_exception_test.cpp ;
-run to_string_test.cpp ;
 run exception_test.cpp ;
 run boost_error_info_test.cpp ;
 run enable_error_info_test.cpp helper1.cpp ;

test/is_output_streamable_test.cpp

@@ -0,0 +1,41 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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/exception/detail/is_output_streamable.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+namespace
+n1
+    {
+    class
+    c1
+        {
+        };
+    }
+
+namespace
+n2
+    {
+    class
+    c2
+        {
+        };
+
+    std::ostream &
+    operator<<( std::ostream & s, c2 const & )
+        {
+        s << "c2";
+        return s;
+        }           
+    }
+
+int
+main()
+    {
+	BOOST_TEST( !boost::is_output_streamable<n1::c1>::value );
+	BOOST_TEST( boost::is_output_streamable<n2::c2>::value );
+	BOOST_TEST( boost::is_output_streamable<int>::value );
+    return boost::report_errors();
+    }

test/to_string_fail.cpp

@@ -0,0 +1,23 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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/exception/to_string.hpp>
+
+namespace
+n1
+    {
+    struct
+    c1
+        {
+        };
+    }
+
+int
+tester()
+    {
+	using namespace boost;
+	(void) to_string(n1::c1());
+	return 1;
+    }

test/to_string_stub_test.cpp

@@ -0,0 +1,98 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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/exception/to_string_stub.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <iostream>
+
+namespace
+n1
+    {
+    class
+    c1
+        {
+        };
+
+    std::string
+    to_string( c1 const & )
+        {
+        return "c1";
+        }           
+    }
+
+namespace
+n2
+    {
+    class
+    c2
+        {
+        };
+
+    std::ostream &
+    operator<<( std::ostream & s, c2 const & )
+        {
+        s << "c2";
+        return s;
+        }           
+    }
+
+namespace
+n3
+    {
+    class
+    c3
+        {
+        };
+
+    std::ostream &
+    operator<<( std::ostream & s, c3 const & )
+        {
+        s << "bad";
+        return s;
+        }           
+
+    std::string
+    to_string( c3 const & )
+        {
+        return "c3";
+        }           
+    }
+
+namespace
+boost
+    {
+    class
+    to_string_tester
+        {
+        };
+    }
+
+template <class T>
+struct
+my_stub
+    {
+    std::string
+    operator()( T const & )
+        {
+        return "stub";
+        }
+    };
+
+int
+main()
+    {
+    using namespace boost;
+    BOOST_TEST( to_string(42)=="42" );
+    BOOST_TEST( to_string(n1::c1())=="c1" );
+    BOOST_TEST( to_string(n2::c2())=="c2" );
+    BOOST_TEST( to_string(n3::c3())=="c3" );
+    BOOST_TEST( to_string_stub(42)=="42" );
+    BOOST_TEST( to_string_stub(n1::c1())=="c1" );
+    BOOST_TEST( to_string_stub(n2::c2())=="c2" );
+    BOOST_TEST( to_string_stub(n3::c3())=="c3" );
+    BOOST_TEST( to_string_stub(to_string_tester(),my_stub<to_string_tester>())=="stub" );
+    BOOST_TEST( !to_string_stub(to_string_tester()).empty() );
+    return boost::report_errors();
+    }

test/to_string_test.cpp

@@ -3,95 +3,58 @@
 //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/exception/to_string_stub.hpp>
+#include <boost/exception/to_string.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <iostream>
 
 namespace
 n1
     {
-    class
+    struct
     c1
         {
         };
-
-    std::string
-    to_string( c1 const & )
-        {
-        return "c1";
-        }           
     }
 
 namespace
 n2
     {
-    class
+    struct
     c2
         {
         };
 
-    std::ostream &
+	std::string
-    operator<<( std::ostream & s, c2 const & )
+    to_string( c2 const & )
         {
-        s << "c2";
+        return "c2";
-        return s;
         }           
     }
 
 namespace
 n3
     {
-    class
+    struct
     c3
         {
         };
 
-    std::ostream &
+	std::ostream &
-    operator<<( std::ostream & s, c3 const & )
+	operator<<( std::ostream & s, c3 const & )
         {
-        s << "bad";
+        return s << "c3";
-        return s;
-        }           
-
-    std::string
-    to_string( c3 const & )
-        {
-        return "c3";
         }           
     }
 
-namespace
-boost
-    {
-    class
-    to_string_tester
-        {
-        };
-    }
-
-template <class T>
-struct
-my_stub
-    {
-    std::string
-    operator()( T const & )
-        {
-        return "stub";
-        }
-    };
-
 int
 main()
     {
-    using namespace boost;
+	using namespace boost;
-    BOOST_TEST( to_string(5)=="5" );
+	BOOST_TEST( !has_to_string<n1::c1>::value );
-    BOOST_TEST( to_string(n1::c1())=="c1" );
+	BOOST_TEST( has_to_string<n2::c2>::value );
-    BOOST_TEST( to_string(n2::c2())=="c2" );
+	BOOST_TEST( has_to_string<n3::c3>::value );
-    BOOST_TEST( to_string(n3::c3())=="c3" );
+	BOOST_TEST( has_to_string<int>::value );
-    BOOST_TEST( to_string_stub(5)=="5" );
+	BOOST_TEST( "c2"==to_string(n2::c2()) );
-    BOOST_TEST( to_string_stub(n1::c1())=="c1" );
+	BOOST_TEST( "c3"==to_string(n3::c3()) );
-    BOOST_TEST( to_string_stub(n2::c2())=="c2" );
+	BOOST_TEST( "42"==to_string(42) );
-    BOOST_TEST( to_string_stub(n3::c3())=="c3" );
-    BOOST_TEST( to_string_stub(to_string_tester(),my_stub<to_string_tester>())=="stub" );
     return boost::report_errors();
     }