1 files changed, 12 insertions, 13 deletions
diff --git a/3rdParty/Boost/src/boost/exception/info.hpp b/3rdParty/Boost/src/boost/exception/info.hpp
index 7b56076..762a950 100644
--- a/3rdParty/Boost/src/boost/exception/info.hpp
+++ b/3rdParty/Boost/src/boost/exception/info.hpp
@@ -1,152 +1,151 @@
 //Copyright (c) 2006-2010 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_8D22C4CA9CC811DCAA9133D256D89593
 #define UUID_8D22C4CA9CC811DCAA9133D256D89593
-#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
 #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma warning(push,1)
 #endif
 
 #include <boost/exception/exception.hpp>
 #include <boost/exception/to_string_stub.hpp>
 #include <boost/exception/detail/error_info_impl.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/config.hpp>
 #include <map>
 
 namespace
 boost
     {
     template <class Tag,class T>
     inline
-    typename enable_if<has_to_string<T>,std::string>::type
-    to_string( error_info<Tag,T> const & x )
+    std::string
+    error_info_name( error_info<Tag,T> const & x )
         {
-        return to_string(x.value());
+        return tag_type_name<Tag>();
         }
 
     template <class Tag,class T>
     inline
-    error_info<Tag,T>::
-    error_info( value_type const & value ):
-        value_(value)
+    std::string
+    to_string( error_info<Tag,T> const & x )
         {
+        return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
         }
 
     template <class Tag,class T>
     inline
     error_info<Tag,T>::
-    ~error_info() throw()
+    error_info( value_type const & value ):
+        value_(value)
         {
         }
 
     template <class Tag,class T>
     inline
-    std::string
     error_info<Tag,T>::
-    tag_typeid_name() const
+    ~error_info() throw()
         {
-        return tag_type_name<Tag>();
         }
 
     template <class Tag,class T>
     inline
     std::string
     error_info<Tag,T>::
-    value_as_string() const
+    name_value_string() const
         {
         return to_string_stub(*this);
         }
 
     namespace
     exception_detail
         {
         class
         error_info_container_impl:
             public error_info_container
             {
             public:
 
             error_info_container_impl():
                 count_(0)
                 {
                 }
 
             ~error_info_container_impl() throw()
                 {
                 }
 
             void
             set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
                 {
                 BOOST_ASSERT(x);
                 info_[typeid_] = x;
                 diagnostic_info_str_.clear();
                 }
 
             shared_ptr<error_info_base>
             get( type_info_ const & ti ) const
                 {
                 error_info_map::const_iterator i=info_.find(ti);
                 if( info_.end()!=i )
                     {
                     shared_ptr<error_info_base> const & p = i->second;
 #ifndef BOOST_NO_RTTI
                     BOOST_ASSERT( *BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==*ti.type_ );
 #endif
                     return p;
                     }
                 return shared_ptr<error_info_base>();
                 }
 
             char const *
             diagnostic_information( char const * header ) const
                 {
                 if( header )
                     {
                     std::ostringstream tmp;
                     tmp << header;
                     for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
                         {
                         error_info_base const & x = *i->second;
-                        tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
+                        tmp << x.name_value_string();
                         }
                     tmp.str().swap(diagnostic_info_str_);
                     }
                 return diagnostic_info_str_.c_str();
                 }
 
             private:
 
             friend class boost::exception;
 
             typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
             error_info_map info_;
             mutable std::string diagnostic_info_str_;
             mutable int count_;
 
             error_info_container_impl( error_info_container_impl const & );
             error_info_container_impl & operator=( error_info_container const & );
 
             void
             add_ref() const
                 {
                 ++count_;
                 }
 
             bool
             release() const
                 {
                 if( --count_ )
                     return false;
                 else
                     {
                     delete this;
                     return true;
                     }
                 }