-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+//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)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
-#include <boost/type.hpp>
#include <boost/exception/exception.hpp>
-#include <boost/exception/error_info.hpp>
#include <boost/exception/to_string_stub.hpp>
-#include <boost/current_function.hpp>
+#include <boost/exception/detail/error_info_impl.hpp>
#include <boost/shared_ptr.hpp>
+#include <boost/config.hpp>
#include <map>
-#define BOOST_ERROR_INFO\
- ::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
- ::boost::throw_file(__FILE__) <<\
- ::boost::throw_line((int)__LINE__)
-
namespace
boost
{
- typedef error_info<struct tag_throw_function,char const *> throw_function;
- typedef error_info<struct tag_throw_file,char const *> throw_file;
- typedef error_info<struct tag_throw_line,int> throw_line;
-
- namespace
- exception_detail
+ template <class Tag,class T>
+ inline
+ typename enable_if<has_to_string<T>,std::string>::type
+ to_string( error_info<Tag,T> const & x )
{
- class
- error_info_base
- {
- public:
-
- virtual std::type_info const & tag_typeid() const = 0;
- virtual std::string value_as_string() const = 0;
-
- protected:
-
-#if BOOST_WORKAROUND( __GNUC__, BOOST_TESTED_AT(4) )
-virtual //Disable bogus GCC warning.
-#endif
- ~error_info_base()
- {
- }
- };
+ return to_string(x.value());
}
template <class Tag,class T>
- class
- error_info:
- public exception_detail::error_info_base
+ inline
+ error_info<Tag,T>::
+ error_info( value_type const & value ):
+ value_(value)
{
- public:
-
- typedef T value_type;
-
- error_info( value_type const & value ):
- value_(value)
- {
- }
-
- value_type const &
- value() const
- {
- return value_;
- }
-
- private:
-
- std::type_info const &
- tag_typeid() const
- {
- return typeid(type<Tag>);
- }
-
- std::string
- value_as_string() const
- {
- return to_string_stub(value_);
- }
+ }
- value_type const value_;
- };
+ template <class Tag,class T>
+ inline
+ error_info<Tag,T>::
+ ~error_info() throw()
+ {
+ }
- template <class E,class Tag,class T>
+ template <class Tag,class T>
inline
- E const &
- operator<<( E const & x, error_info<Tag,T> const & v )
+ std::string
+ error_info<Tag,T>::
+ tag_typeid_name() const
{
- shared_ptr< error_info<Tag,T> > p( new error_info<Tag,T>(v) );
- x.set(p);
- return x;
+ return tag_type_name<Tag>();
}
- template <class ErrorInfo,class E>
+ template <class Tag,class T>
inline
- shared_ptr<typename ErrorInfo::value_type const>
- get_error_info( E const & some_exception )
+ std::string
+ error_info<Tag,T>::
+ value_as_string() const
{
- if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
- if( shared_ptr<exception_detail::error_info_base const> eib = x->get(typeid(ErrorInfo)) )
- {
- BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo const *>(eib.get()) );
- 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>();
+ return to_string_stub(*this);
}
namespace
{
}
- shared_ptr<error_info_base const>
- get( std::type_info const & ti ) const
+ void
+ set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
{
- error_info_map::const_iterator i=info_.find(typeinfo(ti));
+ 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> const & p = i->second;
- BOOST_ASSERT( typeid(*p)==ti );
+ 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 const>();
- }
-
- void
- set( shared_ptr<error_info_base const> const & x )
- {
- BOOST_ASSERT(x);
- info_[typeinfo(typeid(*x))] = x;
- what_.clear();
+ return shared_ptr<error_info_base>();
}
char const *
- diagnostic_information( char const * std_what, std::type_info const & exception_type ) const
+ diagnostic_information( char const * header ) const
{
- if( what_.empty() )
+ if( header )
{
- std::string tmp;
- if( std_what )
- {
- tmp += std_what;
- tmp += '\n';
- }
- tmp += "Dynamic exception type: ";
- tmp += exception_type.name();
- tmp += '\n';
+ BOOST_ASSERT(*header!=0);
+ std::ostringstream tmp;
+ tmp << header;
for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
{
- shared_ptr<error_info_base const> const & x = i->second;
- tmp += '[';
- tmp += x->tag_typeid().name();
- tmp += "] = ";
- tmp += x->value_as_string();
- tmp += '\n';
+ error_info_base const & x = *i->second;
+ tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
}
- what_.swap(tmp);
+ tmp.str().swap(diagnostic_info_str_);
}
- return what_.c_str();
+ return diagnostic_info_str_.c_str();
}
private:
- friend class exception;
-
- struct
- typeinfo
- {
- std::type_info const * type;
+ friend class boost::exception;
- explicit
- typeinfo( std::type_info const & t ):
- type(&t)
- {
- }
-
- bool
- operator<( typeinfo const & b ) const
- {
- return 0!=(type->before(*b.type));
- }
- };
-
- typedef std::map< typeinfo, shared_ptr<error_info_base const> > error_info_map;
+ typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
error_info_map info_;
- std::string mutable what_;
- int mutable count_;
+ 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_;
}
- void
+ bool
release() const
{
- if( !--count_ )
+ if( --count_ )
+ return false;
+ else
+ {
delete this;
+ return true;
+ }
+ }
+
+ refcount_ptr<error_info_container>
+ clone() const
+ {
+ refcount_ptr<error_info_container> p;
+ error_info_container_impl * c=new error_info_container_impl;
+ p.adopt(c);
+ c->info_ = info_;
+ return p;
}
};
- }
- inline
- void
- exception::
- set( shared_ptr<exception_detail::error_info_base const> const & x ) const
- {
- if( !data_ )
- data_ = intrusive_ptr<exception_detail::error_info_container>(new exception_detail::error_info_container_impl);
- data_->set(x);
+ template <class E,class Tag,class T>
+ inline
+ E const &
+ set_info( E const & x, error_info<Tag,T> const & v )
+ {
+ typedef error_info<Tag,T> error_info_tag_t;
+ shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
+ exception_detail::error_info_container * c=x.data_.get();
+ if( !c )
+ x.data_.adopt(c=new exception_detail::error_info_container_impl);
+ c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
+ return x;
+ }
+
+ template <class T>
+ struct
+ derives_boost_exception
+ {
+ enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
+ };
}
+ template <class E,class Tag,class T>
inline
- shared_ptr<exception_detail::error_info_base const>
- exception::
- get( std::type_info const & ti ) const
+ typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
+ operator<<( E const & x, error_info<Tag,T> const & v )
{
- if( data_ )
- return data_->get(ti);
- else
- return shared_ptr<exception_detail::error_info_base const>();
+ return exception_detail::set_info(x,v);
}
}
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(pop)
+#endif
#endif
projects / lyx.git / blobdiff