Added the parts of boost which we need to access shared_ptr and weak_ptr. This will allow for improved memory management of large volumes.

library/include/boost/exception/get_error_info.hpp

@@ -0,0 +1,134 @@
+//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_1A590226753311DD9E4CCF6156D89593
+#define UUID_1A590226753311DD9E4CCF6156D89593
+
+#include <boost/exception/exception.hpp>
+#include <boost/exception/detail/error_info_impl.hpp>
+#include <boost/exception/detail/type_info.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        struct
+        strwrap
+            {
+            std::string str;
+            char const * ptr;
+
+            explicit
+            strwrap( char const * s ):
+                str(s),
+                ptr(&str[0])
+                {
+                }
+
+            private:
+
+            strwrap( strwrap const & );
+            strwrap & operator=( strwrap const & );
+            };
+
+        template <>
+        struct
+        get_info<throw_function>
+            {
+            static
+            shared_ptr<char const * const>
+            get( exception const & x )
+                {
+                if( x.throw_function_ && *x.throw_function_ )
+                    {
+                    shared_ptr<strwrap> s(new strwrap(x.throw_function_));
+                    return shared_ptr<char const *>(s,&s->ptr);
+                    }
+                else
+                    return shared_ptr<char const * const>();
+                }
+            };
+
+        template <>
+        struct
+        get_info<throw_file>
+            {
+            static
+            shared_ptr<char const * const>
+            get( exception const & x )
+                {
+                if( x.throw_file_ && *x.throw_file_ )
+                    {
+                    shared_ptr<strwrap> s(new strwrap(x.throw_file_));
+                    return shared_ptr<char const *>(s,&s->ptr);
+                    }
+                else
+                    return shared_ptr<char const * const>();
+                }
+            };
+
+        template <>
+        struct
+        get_info<throw_line>
+            {
+            static
+            shared_ptr<int const>
+            get( exception const & x )
+                {
+                if( x.throw_line_!=-1 )
+                    return boost::shared_ptr<int>(new int(x.throw_line_));
+                else
+                    return shared_ptr<int const>();
+                }
+            };
+
+        template <class ErrorInfo>
+        struct
+        get_info
+            {
+            static
+            shared_ptr<typename ErrorInfo::value_type const>
+            get( exception const & x )
+                {
+                if( exception_detail::error_info_container * c=x.data_.get() )
+                    if( shared_ptr<exception_detail::error_info_base const> eib = c->get(BOOST_EXCEPTION_STATIC_TYPEID(ErrorInfo)) )
+                        {
+#ifndef BOOST_NO_RTTI
+                        BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo const *>(eib.get()) );
+#endif
+                        ErrorInfo const * w = static_cast<ErrorInfo const *>(eib.get());
+                        return shared_ptr<typename ErrorInfo::value_type const>(eib,&w->value());
+                        }
+                return shared_ptr<typename ErrorInfo::value_type const>();
+                }
+            };
+        }
+
+#ifdef BOOST_NO_RTTI
+    template <class ErrorInfo>
+    inline
+    shared_ptr<typename ErrorInfo::value_type const>
+    get_error_info( boost::exception const & x )
+        {
+        return exception_detail::get_info<ErrorInfo>::get(x);
+        }
+#else
+    template <class ErrorInfo,class E>
+    inline
+    shared_ptr<typename ErrorInfo::value_type const>
+    get_error_info( E const & some_exception )
+        {
+        if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
+            return exception_detail::get_info<ErrorInfo>::get(*x);
+        else
+            return shared_ptr<typename ErrorInfo::value_type const>();
+        }
+#endif
+    }
+
+#endif