mirror of
https://github.com/boostorg/exception.git
synced 2025-07-02 23:36:47 +02:00
Compare commits
13 Commits
boost-1.41
...
boost-1.46
| Author | SHA1 | Date | |
|---|---|---|---|
| 02875b4fbd | |||
| 2a2cf697b1 | |||
| b41047174d | |||
| 41efaba6b8 | |||
| feadd7e878 | |||
| eb810d49cb | |||
| 029bc12c85 | |||
| 879f416926 | |||
| 72c90873d0 | |||
| 9fab32d84c | |||
| d4eb9328ca | |||
| 785cf09730 | |||
| 3191be8955 |
@ -28,10 +28,10 @@ namespace
|
||||
boost
|
||||
{
|
||||
<span class="RenoIncludeSPAN"> <span class="RenoIncludeSPAN">template <class ErrorInfo,class E>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E const & x );
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E const & x );
|
||||
|
||||
template <class ErrorInfo,class E>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E & x );</span></span>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E & x );</span></span>
|
||||
}</pre>
|
||||
</div></div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
See also: <span class="RenoPageList"><a href="boost_exception_all_hpp.html">boost/exception/all.hpp</a> | <a href="error_info.html">error_info</a></span>
|
||||
|
||||
@ -47,7 +47,7 @@ boost
|
||||
<span class="RenoIncludeSPAN">void <span class="RenoLink"><a href="rethrow_exception.html">rethrow_exception</a></span>( <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> const & ep );</span></span>
|
||||
}</pre>
|
||||
</div></div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
See also: <span class="RenoPageList"><a href="boost_exception_all_hpp.html">boost/exception/all.hpp</a> | <a href="copy_exception.html">copy_exception</a> | <a href="current_exception.html">current_exception</a> | <a href="exception_ptr.html">exception_ptr</a> | <a href="original_exception_type.html">original_exception_type</a> | <a href="rethrow_exception.html">rethrow_exception</a> | <a href="synopsis.html">Synopsis</a> | <a href="unknown_exception.html">unknown_exception</a></span>
|
||||
See also: <span class="RenoPageList"><a href="boost_exception_all_hpp.html">boost/exception/all.hpp</a> | <a href="copy_exception.html">copy_exception</a> | <a href="current_exception.html">current_exception</a> | <a href="diagnostic_information.html">diagnostic_information</a> | <a href="exception_ptr.html">exception_ptr</a> | <a href="original_exception_type.html">original_exception_type</a> | <a href="rethrow_exception.html">rethrow_exception</a> | <a href="synopsis.html">Synopsis</a> | <a href="unknown_exception.html">unknown_exception</a></span>
|
||||
</div>
|
||||
<!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
|
||||
<!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->
|
||||
|
||||
@ -39,7 +39,7 @@ catch(...)
|
||||
return <span class="RenoLink"><a href="current_exception.html">current_exception</a></span>();
|
||||
}</pre>
|
||||
</div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a></span>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a> | <a href="current_exception.html">current_exception</a></span>
|
||||
</div>
|
||||
<!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
|
||||
<!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->
|
||||
|
||||
@ -29,6 +29,7 @@ boost
|
||||
}</pre>
|
||||
</div><h4>Requirements:</h4>
|
||||
<p>The <span class="RenoLink">current_exception</span> function must not be called outside of a catch block.</p>
|
||||
<p>In addition, to safely copy an exception from one thread to another, if the exception object is copied by <span class="RenoLink">current_exception</span> or <span class="RenoLink"><a href="copy_exception.html">copy_exception</a></span>, the two copies must not have shared state. Exceptions that have value-type semantics (as well as the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> type itself) satisfy this requirement.</p>
|
||||
<h4>Returns:</h4>
|
||||
<div><ul><li> An <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to the currently handled exception or a copy of the currently handled exception.</li>
|
||||
<li> If the function needs to allocate memory and the attempt fails, it returns an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to an instance of std::bad_alloc.</li>
|
||||
@ -43,7 +44,7 @@ boost
|
||||
</li>
|
||||
</ul></div>
|
||||
</div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a> | <a href="copy_exception.html">copy_exception</a> | <a href="enable_current_exception.html">enable_current_exception</a> | <a href="exception_ptr.html">exception_ptr</a> | <a href="frequently_asked_questions.html">Frequently Asked Questions</a> | <a href="original_exception_type.html">original_exception_type</a> | <a href="unknown_exception.html">unknown_exception</a></span>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a> | <a href="copy_exception.html">copy_exception</a> | <a href="enable_current_exception.html">enable_current_exception</a> | <a href="frequently_asked_questions.html">Frequently Asked Questions</a> | <a href="original_exception_type.html">original_exception_type</a> | <a href="unknown_exception.html">unknown_exception</a></span>
|
||||
</div>
|
||||
<!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
|
||||
<!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->
|
||||
|
||||
@ -21,7 +21,7 @@
|
||||
<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
|
||||
<div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>diagnostic_information</h3>
|
||||
</div>
|
||||
<div class="RenoIncludeDIV"><p><span class="RenoEscape">#<!--<wiki>`#</wiki>--></span>include <<span class="RenoLink"><a href="boost_exception_diagnostic_information_hpp.html">boost/exception/diagnostic_information.hpp</a></span>><span class="RenoBR"> </span><br/></p>
|
||||
<div class="RenoIncludeDIV"><p><span class="RenoEscape">#<!--<wiki>`#</wiki>--></span>include <<span class="RenoLink"><a href="boost_exception_diagnostic_information_hpp.html">boost/exception/diagnostic_information.hpp</a></span>><span class="RenoBR"> </span><br/><span class="RenoEscape">#<!--<wiki>`#</wiki>--></span>include <<span class="RenoLink"><a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a></span>><span class="RenoBR"> </span><br/></p>
|
||||
<pre>namespace
|
||||
boost
|
||||
{
|
||||
@ -33,7 +33,7 @@ boost
|
||||
</div><h4>Returns:</h4>
|
||||
<p>A string value that contains varying amount of implementation-specific diagnostic information about the passed object:</p>
|
||||
<div><ul><li>If E can be statically converted to boost::<span class="RenoLink"><a href="exception.html">exception</a></span>, the returned value contains the string representations of all <span class="RenoLink"><a href="error_info.html">error_info</a></span> objects stored in the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> through <span class="RenoLink"><a href="exception_operator_shl.html">operator<<</a></span>, along with other diagnostic information relevant to the exception. If e can be dynamically converted to std::exception, the returned value also contains the what() string.</li>
|
||||
<li>Otherwise, if E can be statically converted std::exception:<div><ul><li>if e can be dynamically converted to boost::exception, the returned value is the same as if E could be statically converted to boost::<span class="RenoLink"><a href="exception.html">exception</a></span>;</li>
|
||||
<li>Otherwise, if E can be statically converted to std::exception:<div><ul><li>if e can be dynamically converted to boost::exception, the returned value is the same as if E could be statically converted to boost::<span class="RenoLink"><a href="exception.html">exception</a></span>;</li>
|
||||
<li>otherwise the returned value contains the what() string.</li>
|
||||
</ul></div>
|
||||
</li>
|
||||
|
||||
@ -31,11 +31,12 @@ boost
|
||||
<p>The referenced object remains valid at least as long as there is an <span class="RenoLink">exception_ptr</span> object that refers to it.</p>
|
||||
<p>Two instances of <span class="RenoLink">exception_ptr</span> are equivalent and compare equal if and only if they refer to the same exception.</p>
|
||||
<p>The default constructor of <span class="RenoLink">exception_ptr</span> produces the null value of the type. The null value is equivalent only to itself.</p>
|
||||
<h4>Thread safety</h4>
|
||||
<div><ul><li> It is legal for multiple threads to hold <span class="RenoLink">exception_ptr</span> references to the same exception object.</li>
|
||||
<li> It is illegal for multiple threads to modify the same <span class="RenoLink">exception_ptr</span> object concurrently.</li>
|
||||
<li> While calling <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> makes a copy of the current exception object, it is still possible for the two copies to share internal state. Therefore, in general it is not safe to call <span class="RenoLink"><a href="rethrow_exception.html">rethrow_exception</a></span> concurrently to throw the same exception object into multiple threads.</li>
|
||||
<h4>Thread safety:</h4>
|
||||
<p>The <span class="RenoLink">exception_ptr</span> type is "as thread-safe as built-in types":</p>
|
||||
<div><ul><li> An <span class="RenoLink">exception_ptr</span> instance can be "read" simultaneously by multiple threads</li>
|
||||
<li> Different <span class="RenoLink">exception_ptr</span> instances can be "written to" simultaneously by multiple threads, even when these instances refer to the same exception object</li>
|
||||
</ul></div>
|
||||
<p>All other simultaneous accesses result in undefined behavior.</p>
|
||||
<h4>Nesting of exceptions:</h4>
|
||||
<p>An <span class="RenoLink">exception_ptr</span> can be added as <span class="RenoLink"><a href="error_info.html">error_info</a></span> to any boost::<span class="RenoLink"><a href="exception.html">exception</a></span>. This is a convenient way to nest exceptions. There is no limit on the depth of the nesting, however cyclic references result in undefined behavior.</p>
|
||||
</div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
|
||||
@ -25,10 +25,10 @@
|
||||
boost
|
||||
{
|
||||
<span class="RenoIncludeSPAN"> template <class ErrorInfo,class E>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E const & x );
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> const * get_error_info( E const & x );
|
||||
|
||||
template <class ErrorInfo,class E>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E & x );</span>
|
||||
typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> * get_error_info( E & x );</span>
|
||||
}</pre>
|
||||
</div><h4>Requirements:</h4>
|
||||
<div><ul><li> ErrorInfo must be an instance of the <span class="RenoLink"><a href="error_info.html">error_info</a></span> template.</li>
|
||||
|
||||
@ -32,7 +32,7 @@ boost
|
||||
<h4>Throws:</h4>
|
||||
<p>The exception to which ep refers.</p>
|
||||
</div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a> | <a href="diagnostic_information.html">diagnostic_information</a> | <a href="exception_ptr.html">exception_ptr</a></span>
|
||||
See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a> | <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a> | <a href="diagnostic_information.html">diagnostic_information</a></span>
|
||||
</div>
|
||||
<!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
|
||||
<!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_316FDA946C0D11DEA9CBAE5255D89593
|
||||
#define UUID_316FDA946C0D11DEA9CBAE5255D89593
|
||||
#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/exception/diagnostic_information.hpp>
|
||||
#include <boost/exception/error_info.hpp>
|
||||
@ -24,4 +30,7 @@
|
||||
#include <boost/exception_ptr.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_7E83C166200811DE885E826156D89593
|
||||
#define UUID_7E83C166200811DE885E826156D89593
|
||||
#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
|
||||
|
||||
namespace
|
||||
boost
|
||||
@ -31,4 +37,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -6,9 +6,7 @@
|
||||
#ifndef UUID_61531AB0680611DEADD5846855D89593
|
||||
#define UUID_61531AB0680611DEADD5846855D89593
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER)
|
||||
#define BOOST_ATTRIBUTE_NORETURN __declspec(noreturn)
|
||||
#elif defined(__GNUC__)
|
||||
#define BOOST_ATTRIBUTE_NORETURN __attribute__((noreturn))
|
||||
|
||||
@ -1,10 +1,16 @@
|
||||
//Copyright (c) 2006-2009 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_CE6983AC753411DDA764247956D89593
|
||||
#define UUID_CE6983AC753411DDA764247956D89593
|
||||
#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 <string>
|
||||
|
||||
@ -19,12 +25,11 @@ boost
|
||||
{
|
||||
public:
|
||||
|
||||
virtual char const * tag_typeid_name() const = 0;
|
||||
virtual std::string tag_typeid_name() const = 0;
|
||||
virtual std::string value_as_string() const = 0;
|
||||
|
||||
protected:
|
||||
|
||||
virtual
|
||||
~error_info_base() throw()
|
||||
{
|
||||
}
|
||||
@ -57,11 +62,14 @@ boost
|
||||
|
||||
private:
|
||||
|
||||
char const * tag_typeid_name() const;
|
||||
std::string tag_typeid_name() const;
|
||||
std::string value_as_string() const;
|
||||
|
||||
value_type value_;
|
||||
};
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
431
include/boost/exception/detail/exception_ptr.hpp
Normal file
431
include/boost/exception/detail/exception_ptr.hpp
Normal file
@ -0,0 +1,431 @@
|
||||
//Copyright (c) 2006-2009 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_618474C2DE1511DEB74A388C56D89593
|
||||
#define UUID_618474C2DE1511DEB74A388C56D89593
|
||||
#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/config.hpp>
|
||||
#ifdef BOOST_NO_EXCEPTIONS
|
||||
#error This header requires exception handling to be enabled.
|
||||
#endif
|
||||
#include <boost/exception/exception.hpp>
|
||||
#include <boost/exception/info.hpp>
|
||||
#include <boost/exception/diagnostic_information.hpp>
|
||||
#include <boost/exception/detail/type_info.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <stdexcept>
|
||||
#include <new>
|
||||
#include <ios>
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
typedef shared_ptr<exception_detail::clone_base const> exception_ptr;
|
||||
|
||||
exception_ptr current_exception();
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
exception_ptr
|
||||
copy_exception( T const & e )
|
||||
{
|
||||
try
|
||||
{
|
||||
throw enable_current_exception(e);
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return current_exception();
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_RTTI
|
||||
typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
|
||||
|
||||
inline
|
||||
std::string
|
||||
to_string( original_exception_type const & x )
|
||||
{
|
||||
return x.value()->name();
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
struct
|
||||
bad_alloc_:
|
||||
boost::exception,
|
||||
std::bad_alloc
|
||||
{
|
||||
};
|
||||
|
||||
template <int Dummy>
|
||||
exception_ptr
|
||||
get_bad_alloc()
|
||||
{
|
||||
bad_alloc_ ba;
|
||||
exception_detail::clone_impl<bad_alloc_> c(ba);
|
||||
c <<
|
||||
throw_function(BOOST_CURRENT_FUNCTION) <<
|
||||
throw_file(__FILE__) <<
|
||||
throw_line(__LINE__);
|
||||
static exception_ptr ep(new exception_detail::clone_impl<bad_alloc_>(c));
|
||||
return ep;
|
||||
}
|
||||
|
||||
template <int Dummy>
|
||||
struct
|
||||
exception_ptr_bad_alloc
|
||||
{
|
||||
static exception_ptr const e;
|
||||
};
|
||||
|
||||
template <int Dummy>
|
||||
exception_ptr const
|
||||
exception_ptr_bad_alloc<Dummy>::
|
||||
e = get_bad_alloc<Dummy>();
|
||||
}
|
||||
|
||||
class
|
||||
unknown_exception:
|
||||
public boost::exception,
|
||||
public std::exception
|
||||
{
|
||||
public:
|
||||
|
||||
unknown_exception()
|
||||
{
|
||||
}
|
||||
|
||||
explicit
|
||||
unknown_exception( std::exception const & e )
|
||||
{
|
||||
add_original_type(e);
|
||||
}
|
||||
|
||||
explicit
|
||||
unknown_exception( boost::exception const & e ):
|
||||
boost::exception(e)
|
||||
{
|
||||
add_original_type(e);
|
||||
}
|
||||
|
||||
~unknown_exception() throw()
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template <class E>
|
||||
void
|
||||
add_original_type( E const & e )
|
||||
{
|
||||
#ifndef BOOST_NO_RTTI
|
||||
(*this) << original_exception_type(&typeid(e));
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
template <class T>
|
||||
class
|
||||
current_exception_std_exception_wrapper:
|
||||
public T,
|
||||
public boost::exception
|
||||
{
|
||||
public:
|
||||
|
||||
explicit
|
||||
current_exception_std_exception_wrapper( T const & e1 ):
|
||||
T(e1)
|
||||
{
|
||||
add_original_type(e1);
|
||||
}
|
||||
|
||||
current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ):
|
||||
T(e1),
|
||||
boost::exception(e2)
|
||||
{
|
||||
add_original_type(e1);
|
||||
}
|
||||
|
||||
~current_exception_std_exception_wrapper() throw()
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template <class E>
|
||||
void
|
||||
add_original_type( E const & e )
|
||||
{
|
||||
#ifndef BOOST_NO_RTTI
|
||||
(*this) << original_exception_type(&typeid(e));
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef BOOST_NO_RTTI
|
||||
template <class T>
|
||||
boost::exception const *
|
||||
get_boost_exception( T const * )
|
||||
{
|
||||
try
|
||||
{
|
||||
throw;
|
||||
}
|
||||
catch(
|
||||
boost::exception & x )
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
#else
|
||||
template <class T>
|
||||
boost::exception const *
|
||||
get_boost_exception( T const * x )
|
||||
{
|
||||
return dynamic_cast<boost::exception const *>(x);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception_std_exception( T const & e1 )
|
||||
{
|
||||
if( boost::exception const * e2 = get_boost_exception(&e1) )
|
||||
return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
|
||||
else
|
||||
return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception_unknown_exception()
|
||||
{
|
||||
return boost::copy_exception(unknown_exception());
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception_unknown_boost_exception( boost::exception const & e )
|
||||
{
|
||||
return boost::copy_exception(unknown_exception(e));
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception_unknown_std_exception( std::exception const & e )
|
||||
{
|
||||
if( boost::exception const * be = get_boost_exception(&e) )
|
||||
return current_exception_unknown_boost_exception(*be);
|
||||
else
|
||||
return boost::copy_exception(unknown_exception(e));
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception_impl()
|
||||
{
|
||||
try
|
||||
{
|
||||
throw;
|
||||
}
|
||||
catch(
|
||||
exception_detail::clone_base & e )
|
||||
{
|
||||
return exception_ptr(e.clone());
|
||||
}
|
||||
catch(
|
||||
std::domain_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::invalid_argument & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::length_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::out_of_range & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::logic_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::range_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::overflow_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::underflow_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::ios_base::failure & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::runtime_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
#ifndef BOOST_NO_TYPEID
|
||||
catch(
|
||||
std::bad_cast & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::bad_typeid & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
#endif
|
||||
catch(
|
||||
std::bad_exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
boost::exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_boost_exception(e);
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_exception();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception()
|
||||
{
|
||||
exception_ptr ret;
|
||||
BOOST_ASSERT(!ret);
|
||||
try
|
||||
{
|
||||
ret=exception_detail::current_exception_impl();
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & )
|
||||
{
|
||||
ret=exception_detail::exception_ptr_bad_alloc<42>::e;
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
try
|
||||
{
|
||||
ret=exception_detail::current_exception_std_exception(std::bad_exception());
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & )
|
||||
{
|
||||
ret=exception_detail::exception_ptr_bad_alloc<42>::e;
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
BOOST_ASSERT(0);
|
||||
}
|
||||
}
|
||||
BOOST_ASSERT(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
rethrow_exception( exception_ptr const & p )
|
||||
{
|
||||
BOOST_ASSERT(p);
|
||||
p->rethrow();
|
||||
}
|
||||
|
||||
inline
|
||||
std::string
|
||||
diagnostic_information( exception_ptr const & p )
|
||||
{
|
||||
if( p )
|
||||
try
|
||||
{
|
||||
rethrow_exception(p);
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return current_exception_diagnostic_information();
|
||||
}
|
||||
return "<empty>";
|
||||
}
|
||||
|
||||
inline
|
||||
std::string
|
||||
to_string( exception_ptr const & p )
|
||||
{
|
||||
std::string s='\n'+diagnostic_information(p);
|
||||
std::string padding(" ");
|
||||
std::string r;
|
||||
bool f=false;
|
||||
for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
|
||||
{
|
||||
if( f )
|
||||
r+=padding;
|
||||
char c=*i;
|
||||
r+=c;
|
||||
f=(c=='\n');
|
||||
}
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
@ -1,26 +0,0 @@
|
||||
//Copyright (c) 2006-2009 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_DC4208C6417811DEBF11E1EC55D89593
|
||||
#define UUID_DC4208C6417811DEBF11E1EC55D89593
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
class
|
||||
exception_ptr_base
|
||||
{
|
||||
public:
|
||||
|
||||
virtual void _rethrow() const=0;
|
||||
virtual bool _empty() const=0;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_898984B4076411DD973EDFA055D89593
|
||||
#define UUID_898984B4076411DD973EDFA055D89593
|
||||
#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 <ostream>
|
||||
|
||||
@ -14,8 +20,21 @@ boost
|
||||
namespace
|
||||
to_string_detail
|
||||
{
|
||||
template <class T,class CharT,class Traits>
|
||||
char operator<<( std::basic_ostream<CharT,Traits> &, T const & );
|
||||
struct
|
||||
partial_ordering_helper1
|
||||
{
|
||||
template <class CharT,class Traits>
|
||||
partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
|
||||
};
|
||||
|
||||
struct
|
||||
partial_ordering_helper2
|
||||
{
|
||||
template <class T>
|
||||
partial_ordering_helper2( T const & );
|
||||
};
|
||||
|
||||
char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
|
||||
|
||||
template <class T,class CharT,class Traits>
|
||||
struct
|
||||
@ -35,4 +54,7 @@ boost
|
||||
};
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,12 +5,19 @@
|
||||
|
||||
#ifndef UUID_6F463AC838DF11DDA3E6909F56D89593
|
||||
#define UUID_6F463AC838DF11DDA3E6909F56D89593
|
||||
#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/exception/detail/type_info.hpp>
|
||||
#include <iomanip>
|
||||
#include <ios>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace
|
||||
boost
|
||||
@ -21,11 +28,11 @@ boost
|
||||
template <class T>
|
||||
inline
|
||||
std::string
|
||||
object_hex_dump( T const & x, size_t max_size=16 )
|
||||
object_hex_dump( T const & x, std::size_t max_size=16 )
|
||||
{
|
||||
std::ostringstream s;
|
||||
s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
|
||||
size_t n=sizeof(T)>max_size?max_size:sizeof(T);
|
||||
std::size_t n=sizeof(T)>max_size?max_size:sizeof(T);
|
||||
s.fill('0');
|
||||
s.width(2);
|
||||
unsigned char const * b=reinterpret_cast<unsigned char const *>(&x);
|
||||
@ -37,4 +44,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -1,130 +1,83 @@
|
||||
//Copyright (c) 2006-2009 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_C3E1741C754311DDB2834CCA55D89593
|
||||
#define UUID_C3E1741C754311DDB2834CCA55D89593
|
||||
#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/detail/sp_typeinfo.hpp>
|
||||
#include <boost/current_function.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#ifndef BOOST_NO_TYPEID
|
||||
#include <boost/units/detail/utility.hpp>
|
||||
#endif
|
||||
#include <string>
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
template <class T>
|
||||
inline
|
||||
char const *
|
||||
std::string
|
||||
tag_type_name()
|
||||
{
|
||||
#ifdef BOOST_NO_TYPEID
|
||||
return BOOST_CURRENT_FUNCTION;
|
||||
#else
|
||||
return typeid(T*).name();
|
||||
return units::detail::demangle(typeid(T*).name());
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
char const *
|
||||
std::string
|
||||
type_name()
|
||||
{
|
||||
#ifdef BOOST_NO_TYPEID
|
||||
return BOOST_CURRENT_FUNCTION;
|
||||
#else
|
||||
return typeid(T).name();
|
||||
return units::detail::demangle(typeid(T).name());
|
||||
#endif
|
||||
}
|
||||
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
#ifdef BOOST_NO_TYPEID
|
||||
struct
|
||||
type_info_
|
||||
{
|
||||
detail::sp_typeinfo type_;
|
||||
char const * name_;
|
||||
|
||||
explicit
|
||||
type_info_( detail::sp_typeinfo type, char const * name ):
|
||||
type_(type),
|
||||
name_(name)
|
||||
{
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator==( type_info_ const & a, type_info_ const & b )
|
||||
{
|
||||
return a.type_==b.type_;
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator<( type_info_ const & a, type_info_ const & b )
|
||||
{
|
||||
return a.type_<b.type_;
|
||||
}
|
||||
|
||||
char const *
|
||||
name() const
|
||||
{
|
||||
return name_;
|
||||
}
|
||||
};
|
||||
#else
|
||||
struct
|
||||
type_info_
|
||||
{
|
||||
detail::sp_typeinfo const * type_;
|
||||
detail::sp_typeinfo const & type_;
|
||||
|
||||
explicit
|
||||
type_info_( detail::sp_typeinfo const & type ):
|
||||
type_(&type)
|
||||
type_(type)
|
||||
{
|
||||
}
|
||||
|
||||
type_info_( detail::sp_typeinfo const & type, char const * ):
|
||||
type_(&type)
|
||||
{
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator==( type_info_ const & a, type_info_ const & b )
|
||||
{
|
||||
return (*a.type_)==(*b.type_);
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator<( type_info_ const & a, type_info_ const & b )
|
||||
{
|
||||
return 0!=(a.type_->before(*b.type_));
|
||||
}
|
||||
|
||||
char const *
|
||||
name() const
|
||||
{
|
||||
return type_->name();
|
||||
return 0!=(a.type_.before(b.type_));
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
inline
|
||||
bool
|
||||
operator!=( type_info_ const & a, type_info_ const & b )
|
||||
{
|
||||
return !(a==b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define BOOST_EXCEPTION_STATIC_TYPEID(T) ::boost::exception_detail::type_info_(BOOST_SP_TYPEID(T),::boost::tag_type_name<T>())
|
||||
#define BOOST_EXCEPTION_STATIC_TYPEID(T) ::boost::exception_detail::type_info_(BOOST_SP_TYPEID(T))
|
||||
|
||||
#ifndef BOOST_NO_RTTI
|
||||
#define BOOST_EXCEPTION_DYNAMIC_TYPEID(x) ::boost::exception_detail::type_info_(typeid(x))
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -1,46 +1,85 @@
|
||||
//Copyright (c) 2006-2009 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_0552D49838DD11DD90146B8956D89593
|
||||
#define UUID_0552D49838DD11DD90146B8956D89593
|
||||
#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/config.hpp>
|
||||
#include <boost/exception/get_error_info.hpp>
|
||||
#include <boost/exception/detail/exception_ptr_base.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#ifndef BOOST_NO_RTTI
|
||||
#include <boost/units/detail/utility.hpp>
|
||||
#endif
|
||||
#include <exception>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#include <boost/exception/current_exception_cast.hpp>
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool );
|
||||
}
|
||||
|
||||
inline
|
||||
std::string
|
||||
current_exception_diagnostic_information()
|
||||
{
|
||||
boost::exception const * be=current_exception_cast<boost::exception const>();
|
||||
std::exception const * se=current_exception_cast<std::exception const>();
|
||||
if( be || se )
|
||||
return exception_detail::diagnostic_information_impl(be,se,true);
|
||||
else
|
||||
return "No diagnostic information available.";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
template <class T>
|
||||
struct
|
||||
enable_boost_exception_overload
|
||||
inline
|
||||
exception const *
|
||||
get_boost_exception( exception const * e )
|
||||
{
|
||||
struct yes { char q[100]; };
|
||||
typedef char no;
|
||||
static yes check(exception const *);
|
||||
static no check(...);
|
||||
enum e { value=sizeof(check((T*)0))==sizeof(yes) };
|
||||
};
|
||||
return e;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct
|
||||
enable_std_exception_overload
|
||||
inline
|
||||
exception const *
|
||||
get_boost_exception( ... )
|
||||
{
|
||||
struct yes { char q[100]; };
|
||||
typedef char no;
|
||||
static yes check(std::exception const *);
|
||||
static no check(...);
|
||||
enum e { value = !enable_boost_exception_overload<T>::value && sizeof(check((T*)0))==sizeof(yes) };
|
||||
};
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline
|
||||
std::exception const *
|
||||
get_std_exception( std::exception const * e )
|
||||
{
|
||||
return e;
|
||||
}
|
||||
|
||||
inline
|
||||
std::exception const *
|
||||
get_std_exception( ... )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline
|
||||
char const *
|
||||
@ -65,12 +104,13 @@ boost
|
||||
std::string
|
||||
diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what )
|
||||
{
|
||||
BOOST_ASSERT(be||se);
|
||||
if( !be && !se )
|
||||
return "Unknown exception.";
|
||||
#ifndef BOOST_NO_RTTI
|
||||
if( !se )
|
||||
se = dynamic_cast<std::exception const *>(be);
|
||||
if( !be )
|
||||
be = dynamic_cast<boost::exception const *>(se);
|
||||
be=dynamic_cast<boost::exception const *>(se);
|
||||
if( !se )
|
||||
se=dynamic_cast<std::exception const *>(be);
|
||||
#endif
|
||||
char const * wh=0;
|
||||
if( with_what && se )
|
||||
@ -97,7 +137,7 @@ boost
|
||||
}
|
||||
#ifndef BOOST_NO_RTTI
|
||||
tmp << std::string("Dynamic exception type: ") <<
|
||||
(be?BOOST_EXCEPTION_DYNAMIC_TYPEID(*be):BOOST_EXCEPTION_DYNAMIC_TYPEID(*se)).name() << '\n';
|
||||
units::detail::demangle((be?(BOOST_EXCEPTION_DYNAMIC_TYPEID(*be)):(BOOST_EXCEPTION_DYNAMIC_TYPEID(*se))).type_.name()) << '\n';
|
||||
#endif
|
||||
if( with_what && se )
|
||||
tmp << "std::exception::what: " << wh << '\n';
|
||||
@ -110,19 +150,10 @@ boost
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
typename enable_if<exception_detail::enable_boost_exception_overload<T>,std::string>::type
|
||||
std::string
|
||||
diagnostic_information( T const & e )
|
||||
{
|
||||
return exception_detail::diagnostic_information_impl(&e,0,true);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
typename enable_if<exception_detail::enable_std_exception_overload<T>,std::string>::type
|
||||
diagnostic_information( T const & e )
|
||||
{
|
||||
return exception_detail::diagnostic_information_impl(0,&e,true);
|
||||
return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true);
|
||||
}
|
||||
|
||||
inline
|
||||
@ -147,40 +178,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
#include <boost/exception/current_exception_cast.hpp>
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
inline
|
||||
std::string
|
||||
current_exception_diagnostic_information()
|
||||
{
|
||||
boost::exception const * be=current_exception_cast<boost::exception const>();
|
||||
std::exception const * se=current_exception_cast<std::exception const>();
|
||||
if( be || se )
|
||||
return exception_detail::diagnostic_information_impl(be,se,true);
|
||||
else
|
||||
return "No diagnostic information available.";
|
||||
}
|
||||
|
||||
inline
|
||||
std::string
|
||||
diagnostic_information( exception_detail::exception_ptr_base const & p )
|
||||
{
|
||||
if( !p._empty() )
|
||||
try
|
||||
{
|
||||
p._rethrow();
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return current_exception_diagnostic_information();
|
||||
}
|
||||
return "<empty>";
|
||||
}
|
||||
}
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_F0EE17BE6C1211DE87FF459155D89593
|
||||
#define UUID_F0EE17BE6C1211DE87FF459155D89593
|
||||
#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/exception/info.hpp"
|
||||
#include <errno.h>
|
||||
@ -32,4 +38,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -9,8 +9,10 @@
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
namespace exception_detail { class clone_base; };
|
||||
template <class Tag,class T> class error_info;
|
||||
class exception_ptr;
|
||||
template <class T> class shared_ptr;
|
||||
typedef shared_ptr<exception_detail::clone_base const> exception_ptr;
|
||||
typedef error_info<struct errinfo_nested_exception_,exception_ptr> errinfo_nested_exception;
|
||||
}
|
||||
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_274DA366004E11DCB1DDFE2E56D89593
|
||||
#define UUID_274DA366004E11DCB1DDFE2E56D89593
|
||||
#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
|
||||
|
||||
namespace
|
||||
boost
|
||||
@ -69,8 +75,8 @@ boost
|
||||
void
|
||||
release()
|
||||
{
|
||||
if( px_ )
|
||||
px_->release();
|
||||
if( px_ && px_->release() )
|
||||
px_=0;
|
||||
}
|
||||
};
|
||||
}
|
||||
@ -126,12 +132,9 @@ boost
|
||||
}
|
||||
};
|
||||
|
||||
template <class E,class Tag,class T>
|
||||
E const & operator<<( E const &, error_info<Tag,T> const & );
|
||||
|
||||
class exception;
|
||||
|
||||
template <class>
|
||||
template <class T>
|
||||
class shared_ptr;
|
||||
|
||||
namespace
|
||||
@ -147,11 +150,11 @@ boost
|
||||
virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
|
||||
virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
|
||||
virtual void add_ref() const = 0;
|
||||
virtual void release() const = 0;
|
||||
virtual bool release() const = 0;
|
||||
virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
|
||||
|
||||
protected:
|
||||
|
||||
virtual
|
||||
~error_info_container() throw()
|
||||
{
|
||||
}
|
||||
@ -170,6 +173,20 @@ boost
|
||||
struct get_info<throw_line>;
|
||||
|
||||
char const * get_diagnostic_information( exception const &, char const * );
|
||||
|
||||
void copy_boost_exception( exception *, exception const * );
|
||||
|
||||
template <class E,class Tag,class T>
|
||||
E const & set_info( E const &, error_info<Tag,T> const & );
|
||||
|
||||
template <class E>
|
||||
E const & set_info( E const &, throw_function const & );
|
||||
|
||||
template <class E>
|
||||
E const & set_info( E const &, throw_file const & );
|
||||
|
||||
template <class E>
|
||||
E const & set_info( E const &, throw_line const & );
|
||||
}
|
||||
|
||||
class
|
||||
@ -202,46 +219,32 @@ boost
|
||||
#endif
|
||||
;
|
||||
|
||||
#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
|
||||
public:
|
||||
#else
|
||||
private:
|
||||
|
||||
template <class E>
|
||||
friend
|
||||
E const &
|
||||
operator<<( E const & x, throw_function const & y )
|
||||
{
|
||||
x.throw_function_=y.v_;
|
||||
return x;
|
||||
}
|
||||
friend E const & exception_detail::set_info( E const &, throw_function const & );
|
||||
|
||||
template <class E>
|
||||
friend
|
||||
E const &
|
||||
operator<<( E const & x, throw_file const & y )
|
||||
{
|
||||
x.throw_file_=y.v_;
|
||||
return x;
|
||||
}
|
||||
friend E const & exception_detail::set_info( E const &, throw_file const & );
|
||||
|
||||
template <class E>
|
||||
friend
|
||||
E const &
|
||||
operator<<( E const & x, throw_line const & y )
|
||||
{
|
||||
x.throw_line_=y.v_;
|
||||
return x;
|
||||
}
|
||||
|
||||
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
|
||||
friend E const & exception_detail::set_info( E const &, throw_line const & );
|
||||
|
||||
template <class E,class Tag,class T>
|
||||
friend E const & operator<<( E const &, error_info<Tag,T> const & );
|
||||
friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
|
||||
|
||||
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
|
||||
|
||||
template <class>
|
||||
friend struct exception_detail::get_info;
|
||||
friend struct exception_detail::get_info<throw_function>;
|
||||
friend struct exception_detail::get_info<throw_file>;
|
||||
friend struct exception_detail::get_info<throw_line>;
|
||||
|
||||
friend void exception_detail::copy_boost_exception( exception *, exception const * );
|
||||
#endif
|
||||
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
|
||||
mutable char const * throw_function_;
|
||||
mutable char const * throw_file_;
|
||||
@ -254,6 +257,34 @@ boost
|
||||
{
|
||||
}
|
||||
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
template <class E>
|
||||
E const &
|
||||
set_info( E const & x, throw_function const & y )
|
||||
{
|
||||
x.throw_function_=y.v_;
|
||||
return x;
|
||||
}
|
||||
|
||||
template <class E>
|
||||
E const &
|
||||
set_info( E const & x, throw_file const & y )
|
||||
{
|
||||
x.throw_file_=y.v_;
|
||||
return x;
|
||||
}
|
||||
|
||||
template <class E>
|
||||
E const &
|
||||
set_info( E const & x, throw_line const & y )
|
||||
{
|
||||
x.throw_line_=y.v_;
|
||||
return x;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace
|
||||
@ -277,10 +308,10 @@ boost
|
||||
};
|
||||
|
||||
struct large_size { char c[256]; };
|
||||
large_size dispatch( exception * );
|
||||
large_size dispatch_boost_exception( exception const * );
|
||||
|
||||
struct small_size { };
|
||||
small_size dispatch( void * );
|
||||
small_size dispatch_boost_exception( void const * );
|
||||
|
||||
template <class,int>
|
||||
struct enable_error_info_helper;
|
||||
@ -303,7 +334,7 @@ boost
|
||||
struct
|
||||
enable_error_info_return_type
|
||||
{
|
||||
typedef typename enable_error_info_helper<T,sizeof(dispatch((T*)0))>::type type;
|
||||
typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception((T*)0))>::type type;
|
||||
};
|
||||
}
|
||||
|
||||
@ -340,7 +371,13 @@ boost
|
||||
void
|
||||
copy_boost_exception( exception * a, exception const * b )
|
||||
{
|
||||
*a = *b;
|
||||
refcount_ptr<error_info_container> data;
|
||||
if( error_info_container * d=b->data_.get() )
|
||||
data = d->clone();
|
||||
a->throw_file_ = b->throw_file_;
|
||||
a->throw_line_ = b->throw_line_;
|
||||
a->throw_function_ = b->throw_function_;
|
||||
a->data_ = data;
|
||||
}
|
||||
|
||||
inline
|
||||
@ -393,4 +430,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_1A590226753311DD9E4CCF6156D89593
|
||||
#define UUID_1A590226753311DD9E4CCF6156D89593
|
||||
#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/exception/exception.hpp>
|
||||
#include <boost/exception/detail/error_info_impl.hpp>
|
||||
@ -118,4 +124,7 @@ boost
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -1,15 +1,22 @@
|
||||
//Copyright (c) 2006-2009 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/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
|
||||
@ -40,7 +47,7 @@ boost
|
||||
|
||||
template <class Tag,class T>
|
||||
inline
|
||||
char const *
|
||||
std::string
|
||||
error_info<Tag,T>::
|
||||
tag_typeid_name() const
|
||||
{
|
||||
@ -90,7 +97,7 @@ boost
|
||||
{
|
||||
shared_ptr<error_info_base> const & p = i->second;
|
||||
#ifndef BOOST_NO_RTTI
|
||||
BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p)==ti );
|
||||
BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==ti.type_ );
|
||||
#endif
|
||||
return p;
|
||||
}
|
||||
@ -107,8 +114,8 @@ boost
|
||||
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 << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << '\n';
|
||||
error_info_base const & x = *i->second;
|
||||
tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
|
||||
}
|
||||
tmp.str().swap(diagnostic_info_str_);
|
||||
}
|
||||
@ -124,34 +131,70 @@ boost
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
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
|
||||
E const &
|
||||
typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
|
||||
operator<<( 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;
|
||||
if( !(c=x.data_.get()) )
|
||||
x.data_.adopt(c=new exception_detail::error_info_container_impl);
|
||||
c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
|
||||
return x;
|
||||
return exception_detail::set_info(x,v);
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_63EE924290FB11DC87BB856555D89593
|
||||
#define UUID_63EE924290FB11DC87BB856555D89593
|
||||
#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/exception/info.hpp>
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
@ -64,4 +70,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_7E48761AD92811DC9011477D56D89593
|
||||
#define UUID_7E48761AD92811DC9011477D56D89593
|
||||
#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/utility/enable_if.hpp>
|
||||
#include <boost/exception/detail/is_output_streamable.hpp>
|
||||
@ -71,4 +77,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -5,6 +5,12 @@
|
||||
|
||||
#ifndef UUID_E788439ED9F011DCB181F25B55D89593
|
||||
#define UUID_E788439ED9F011DCB181F25B55D89593
|
||||
#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/exception/to_string.hpp>
|
||||
#include <boost/exception/detail/object_hex_dump.hpp>
|
||||
@ -97,4 +103,7 @@ boost
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -6,456 +6,6 @@
|
||||
#ifndef UUID_FA5836A2CADA11DC8CD47C8555D89593
|
||||
#define UUID_FA5836A2CADA11DC8CD47C8555D89593
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_NO_EXCEPTIONS
|
||||
#error This header requires exception handling to be enabled.
|
||||
#endif
|
||||
#include <boost/exception/exception.hpp>
|
||||
#include <boost/exception/info.hpp>
|
||||
#include <boost/exception/diagnostic_information.hpp>
|
||||
#include <boost/exception/detail/type_info.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <stdexcept>
|
||||
#include <new>
|
||||
#include <ios>
|
||||
|
||||
namespace
|
||||
boost
|
||||
{
|
||||
#ifndef BOOST_NO_RTTI
|
||||
typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
|
||||
|
||||
inline
|
||||
std::string
|
||||
to_string( original_exception_type const & x )
|
||||
{
|
||||
return x.value()->name();
|
||||
}
|
||||
#endif
|
||||
|
||||
class exception_ptr;
|
||||
exception_ptr current_exception();
|
||||
void rethrow_exception( exception_ptr const & );
|
||||
|
||||
class
|
||||
exception_ptr:
|
||||
public exception_detail::exception_ptr_base
|
||||
{
|
||||
typedef bool exception_ptr::*unspecified_bool_type;
|
||||
friend exception_ptr current_exception();
|
||||
friend void rethrow_exception( exception_ptr const & );
|
||||
|
||||
shared_ptr<exception_detail::clone_base const> c_;
|
||||
bool bad_alloc_;
|
||||
|
||||
struct
|
||||
bad_alloc_tag
|
||||
{
|
||||
};
|
||||
|
||||
explicit
|
||||
exception_ptr( bad_alloc_tag ):
|
||||
bad_alloc_(true)
|
||||
{
|
||||
}
|
||||
|
||||
explicit
|
||||
exception_ptr( shared_ptr<exception_detail::clone_base const> const & c ):
|
||||
c_(c),
|
||||
bad_alloc_(false)
|
||||
{
|
||||
BOOST_ASSERT(c);
|
||||
}
|
||||
|
||||
void
|
||||
_rethrow() const
|
||||
{
|
||||
BOOST_ASSERT(*this);
|
||||
if( bad_alloc_ )
|
||||
throw enable_current_exception(std::bad_alloc());
|
||||
else
|
||||
c_->rethrow();
|
||||
}
|
||||
|
||||
bool
|
||||
_empty() const
|
||||
{
|
||||
return !bad_alloc_ && !c_;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
exception_ptr():
|
||||
bad_alloc_(false)
|
||||
{
|
||||
}
|
||||
|
||||
operator unspecified_bool_type() const
|
||||
{
|
||||
return _empty() ? 0 : &exception_ptr::bad_alloc_;
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator==( exception_ptr const & a, exception_ptr const & b )
|
||||
{
|
||||
return a.c_==b.c_ && a.bad_alloc_==b.bad_alloc_;
|
||||
}
|
||||
|
||||
friend
|
||||
bool
|
||||
operator!=( exception_ptr const & a, exception_ptr const & b )
|
||||
{
|
||||
return !(a==b);
|
||||
}
|
||||
};
|
||||
|
||||
class
|
||||
unknown_exception:
|
||||
public exception,
|
||||
public std::exception,
|
||||
public exception_detail::clone_base
|
||||
{
|
||||
public:
|
||||
|
||||
unknown_exception()
|
||||
{
|
||||
}
|
||||
|
||||
explicit
|
||||
unknown_exception( std::exception const & e )
|
||||
{
|
||||
add_original_type(e);
|
||||
}
|
||||
|
||||
explicit
|
||||
unknown_exception( boost::exception const & e ):
|
||||
boost::exception(e)
|
||||
{
|
||||
add_original_type(e);
|
||||
}
|
||||
|
||||
~unknown_exception() throw()
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
exception_detail::clone_base const *
|
||||
clone() const
|
||||
{
|
||||
return new unknown_exception(*this);
|
||||
}
|
||||
|
||||
void
|
||||
rethrow() const
|
||||
{
|
||||
throw*this;
|
||||
}
|
||||
|
||||
template <class E>
|
||||
void
|
||||
add_original_type( E const & e )
|
||||
{
|
||||
#ifndef BOOST_NO_RTTI
|
||||
(*this) << original_exception_type(&typeid(e));
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
template <class T>
|
||||
class
|
||||
current_exception_std_exception_wrapper:
|
||||
public T,
|
||||
public boost::exception,
|
||||
public clone_base
|
||||
{
|
||||
public:
|
||||
|
||||
explicit
|
||||
current_exception_std_exception_wrapper( T const & e1 ):
|
||||
T(e1)
|
||||
{
|
||||
add_original_type(e1);
|
||||
}
|
||||
|
||||
current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ):
|
||||
T(e1),
|
||||
boost::exception(e2)
|
||||
{
|
||||
add_original_type(e1);
|
||||
}
|
||||
|
||||
~current_exception_std_exception_wrapper() throw()
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
clone_base const *
|
||||
clone() const
|
||||
{
|
||||
return new current_exception_std_exception_wrapper(*this);
|
||||
}
|
||||
|
||||
void
|
||||
rethrow() const
|
||||
{
|
||||
throw *this;
|
||||
}
|
||||
|
||||
template <class E>
|
||||
void
|
||||
add_original_type( E const & e )
|
||||
{
|
||||
#ifndef BOOST_NO_RTTI
|
||||
(*this) << original_exception_type(&typeid(e));
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef BOOST_NO_RTTI
|
||||
template <class T>
|
||||
exception const *
|
||||
get_boost_exception( T const * )
|
||||
{
|
||||
try
|
||||
{
|
||||
throw;
|
||||
}
|
||||
catch(
|
||||
exception & x )
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
#else
|
||||
template <class T>
|
||||
exception const *
|
||||
get_boost_exception( T const * x )
|
||||
{
|
||||
return dynamic_cast<exception const *>(x);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
shared_ptr<clone_base const>
|
||||
current_exception_std_exception( T const & e1 )
|
||||
{
|
||||
if( boost::exception const * e2 = get_boost_exception(&e1) )
|
||||
return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1,*e2));
|
||||
else
|
||||
return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1));
|
||||
}
|
||||
|
||||
inline
|
||||
shared_ptr<clone_base const>
|
||||
current_exception_unknown_exception()
|
||||
{
|
||||
return shared_ptr<unknown_exception const>(new unknown_exception());
|
||||
}
|
||||
|
||||
inline
|
||||
shared_ptr<clone_base const>
|
||||
current_exception_unknown_boost_exception( boost::exception const & e )
|
||||
{
|
||||
return shared_ptr<unknown_exception const>(new unknown_exception(e));
|
||||
}
|
||||
|
||||
inline
|
||||
shared_ptr<clone_base const>
|
||||
current_exception_unknown_std_exception( std::exception const & e )
|
||||
{
|
||||
if( boost::exception const * be = get_boost_exception(&e) )
|
||||
return current_exception_unknown_boost_exception(*be);
|
||||
else
|
||||
return shared_ptr<unknown_exception const>(new unknown_exception(e));
|
||||
}
|
||||
|
||||
inline
|
||||
shared_ptr<clone_base const>
|
||||
current_exception_impl()
|
||||
{
|
||||
try
|
||||
{
|
||||
throw;
|
||||
}
|
||||
catch(
|
||||
exception_detail::clone_base & e )
|
||||
{
|
||||
return shared_ptr<exception_detail::clone_base const>(e.clone());
|
||||
}
|
||||
catch(
|
||||
std::domain_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::invalid_argument & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::length_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::out_of_range & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::logic_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::range_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::overflow_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::underflow_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::ios_base::failure & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::runtime_error & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
#ifndef BOOST_NO_TYPEID
|
||||
catch(
|
||||
std::bad_cast & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::bad_typeid & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
#endif
|
||||
catch(
|
||||
std::bad_exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
std::exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_std_exception(e);
|
||||
}
|
||||
catch(
|
||||
boost::exception & e )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_boost_exception(e);
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return exception_detail::current_exception_unknown_exception();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline
|
||||
exception_ptr
|
||||
current_exception()
|
||||
{
|
||||
try
|
||||
{
|
||||
return exception_ptr(exception_detail::current_exception_impl());
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & )
|
||||
{
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
try
|
||||
{
|
||||
return exception_ptr(exception_detail::current_exception_std_exception(std::bad_exception()));
|
||||
}
|
||||
catch(
|
||||
std::bad_alloc & )
|
||||
{
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
BOOST_ASSERT(0);
|
||||
}
|
||||
}
|
||||
return exception_ptr(exception_ptr::bad_alloc_tag());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
exception_ptr
|
||||
copy_exception( T const & e )
|
||||
{
|
||||
try
|
||||
{
|
||||
throw enable_current_exception(e);
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
return current_exception();
|
||||
}
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
rethrow_exception( exception_ptr const & p )
|
||||
{
|
||||
p._rethrow();
|
||||
}
|
||||
|
||||
inline
|
||||
std::string
|
||||
to_string( exception_ptr const & p )
|
||||
{
|
||||
std::string s='\n'+diagnostic_information(p);
|
||||
std::string padding(" ");
|
||||
std::string r;
|
||||
bool f=false;
|
||||
for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
|
||||
{
|
||||
if( f )
|
||||
r+=padding;
|
||||
char c=*i;
|
||||
r+=c;
|
||||
f=(c=='\n');
|
||||
}
|
||||
return r;
|
||||
}
|
||||
}
|
||||
#include <boost/exception/detail/exception_ptr.hpp>
|
||||
|
||||
#endif
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
|
||||
#include <boost/exception/detail/attribute_noreturn.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <exception>
|
||||
|
||||
#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) )
|
||||
@ -35,17 +36,13 @@
|
||||
#if !defined( BOOST_EXCEPTION_DISABLE )
|
||||
# include <boost/exception/exception.hpp>
|
||||
# include <boost/current_function.hpp>
|
||||
# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(::boost::enable_error_info(x) <<\
|
||||
::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
|
||||
::boost::throw_file(__FILE__) <<\
|
||||
::boost::throw_line((int)__LINE__))
|
||||
# define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_CURRENT_FUNCTION,__FILE__,__LINE__)
|
||||
#else
|
||||
# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
#ifdef BOOST_NO_EXCEPTIONS
|
||||
|
||||
void throw_exception( std::exception const & e ); // user defined
|
||||
@ -56,7 +53,7 @@ inline void throw_exception_assert_compatibility( std::exception const & ) { }
|
||||
|
||||
template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e )
|
||||
{
|
||||
//All boost exceptions are required to derive std::exception,
|
||||
//All boost exceptions are required to derive from std::exception,
|
||||
//to ensure compatibility with BOOST_NO_EXCEPTIONS.
|
||||
throw_exception_assert_compatibility(e);
|
||||
|
||||
@ -69,6 +66,26 @@ template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined( BOOST_EXCEPTION_DISABLE )
|
||||
namespace
|
||||
exception_detail
|
||||
{
|
||||
template <class E>
|
||||
BOOST_ATTRIBUTE_NORETURN
|
||||
void
|
||||
throw_exception_( E const & x, char const * current_function, char const * file, int line )
|
||||
{
|
||||
boost::throw_exception(
|
||||
set_info(
|
||||
set_info(
|
||||
set_info(
|
||||
boost::enable_error_info(x),
|
||||
throw_function(current_function)),
|
||||
throw_file(file)),
|
||||
throw_line(line)));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
class my_exception: public std::exception { };
|
||||
|
||||
int
|
||||
|
||||
@ -24,7 +24,7 @@ run 2-throw_exception_no_exceptions_test.cpp ;
|
||||
run 3-throw_exception_no_integration_test.cpp ;
|
||||
run 4-throw_exception_no_both_test.cpp ;
|
||||
run cloning_test.cpp ;
|
||||
run copy_exception_test.cpp ;
|
||||
run copy_exception_test.cpp /boost//thread : : : <threading>multi ;
|
||||
run unknown_exception_test.cpp ;
|
||||
run exception_test.cpp ;
|
||||
run enable_error_info_test.cpp helper1.cpp ;
|
||||
@ -36,6 +36,7 @@ run refcount_ptr_test.cpp ;
|
||||
run current_exception_cast_test.cpp ;
|
||||
run no_exceptions_test.cpp : : : <exception-handling>off ;
|
||||
run errinfos_test.cpp ;
|
||||
run exception_ptr_test.cpp /boost//thread : : : <threading>multi ;
|
||||
compile-fail exception_fail.cpp ;
|
||||
compile-fail throw_exception_fail.cpp ;
|
||||
compile-fail error_info_const_fail.cpp ;
|
||||
@ -45,7 +46,6 @@ compile-fail error_info_const_fail.cpp ;
|
||||
compile exception_ptr_hpp_test.cpp ;
|
||||
compile diagnostic_information_hpp_test.cpp ;
|
||||
compile error_info_hpp_test.cpp ;
|
||||
compile exception_hpp_test.cpp ;
|
||||
compile get_error_info_hpp_test.cpp ;
|
||||
compile info_hpp_test.cpp ;
|
||||
compile info_tuple_hpp_test.cpp ;
|
||||
|
||||
@ -10,10 +10,6 @@
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <string>
|
||||
|
||||
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
|
||||
struct my_tag {};
|
||||
#endif
|
||||
|
||||
typedef boost::error_info<struct my_tag,int> my_info;
|
||||
|
||||
template <class T>
|
||||
@ -556,7 +552,7 @@ main()
|
||||
}
|
||||
try
|
||||
{
|
||||
throw boost::enable_current_exception(derives_std_boost_exception("what2") << boost::errinfo_nested_exception(p) );
|
||||
throw boost::enable_current_exception(derives_std_boost_exception("what2") << boost::errinfo_nested_exception(p) );
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
|
||||
@ -4,25 +4,106 @@
|
||||
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/exception_ptr.hpp>
|
||||
#include <boost/exception/get_error_info.hpp>
|
||||
#include <boost/thread.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
typedef boost::error_info<struct tag_answer,int> answer;
|
||||
|
||||
struct
|
||||
test_exception:
|
||||
std::exception
|
||||
err:
|
||||
virtual boost::exception,
|
||||
virtual std::exception
|
||||
{
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
class
|
||||
future
|
||||
{
|
||||
boost::exception_ptr p = boost::copy_exception(test_exception());
|
||||
public:
|
||||
|
||||
future ():
|
||||
ready_ (false)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
set_exception( boost::exception_ptr const & e )
|
||||
{
|
||||
boost::unique_lock<boost::mutex> lck (mux_);
|
||||
exc_ = e;
|
||||
ready_ = true;
|
||||
cond_.notify_all();
|
||||
}
|
||||
|
||||
void
|
||||
get_exception() const
|
||||
{
|
||||
boost::unique_lock<boost::mutex> lck (mux_);
|
||||
while (! ready_)
|
||||
cond_.wait (lck);
|
||||
rethrow_exception (exc_);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
bool ready_;
|
||||
boost::exception_ptr exc_;
|
||||
mutable boost::mutex mux_;
|
||||
mutable boost::condition_variable cond_;
|
||||
};
|
||||
|
||||
void
|
||||
producer( future & f )
|
||||
{
|
||||
f.set_exception (boost::copy_exception (err () << answer(42)));
|
||||
}
|
||||
|
||||
void
|
||||
consumer()
|
||||
{
|
||||
future f;
|
||||
boost::thread thr (boost::bind (&producer, boost::ref (f)));
|
||||
try
|
||||
{
|
||||
f.get_exception ();
|
||||
}
|
||||
catch(
|
||||
err & e )
|
||||
{
|
||||
int const * ans=boost::get_error_info<answer>(e);
|
||||
BOOST_TEST(ans && *ans==42);
|
||||
}
|
||||
thr.join();
|
||||
}
|
||||
|
||||
void
|
||||
consume()
|
||||
{
|
||||
for( int i=0; i!=100; ++i )
|
||||
consumer();
|
||||
}
|
||||
|
||||
void
|
||||
thread_test()
|
||||
{
|
||||
boost::thread_group grp;
|
||||
for( int i=0; i!=50; ++i )
|
||||
grp.create_thread(&consume);
|
||||
grp.join_all ();
|
||||
}
|
||||
|
||||
void
|
||||
simple_test()
|
||||
{
|
||||
boost::exception_ptr p = boost::copy_exception(err());
|
||||
try
|
||||
{
|
||||
rethrow_exception(p);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(
|
||||
test_exception & )
|
||||
err & )
|
||||
{
|
||||
}
|
||||
catch(
|
||||
@ -30,5 +111,12 @@ main()
|
||||
{
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
simple_test();
|
||||
thread_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -34,7 +34,7 @@ main()
|
||||
e <<
|
||||
errinfo_api_function("failed_api_function") <<
|
||||
errinfo_at_line(42) <<
|
||||
errinfo_errno(errno) <<
|
||||
errinfo_errno(0) <<
|
||||
errinfo_file_handle(weak_ptr<FILE>()) <<
|
||||
errinfo_file_name("filename.txt") <<
|
||||
errinfo_file_open_mode("rb");
|
||||
@ -43,7 +43,7 @@ main()
|
||||
#else
|
||||
BOOST_THROW_EXCEPTION(e<<errinfo_type_info_name(typeid(int).name()));
|
||||
#endif
|
||||
BOOST_TEST(false);
|
||||
BOOST_ERROR("BOOST_THROW_EXCEPTION failed to throw.");
|
||||
}
|
||||
catch(
|
||||
boost::exception & e )
|
||||
|
||||
@ -9,10 +9,6 @@
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <errno.h>
|
||||
|
||||
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
|
||||
struct tag_errno {};
|
||||
#endif
|
||||
|
||||
typedef boost::error_info<struct tag_errno,int> info_errno;
|
||||
|
||||
class
|
||||
@ -28,7 +24,6 @@ main()
|
||||
{
|
||||
errno=1;
|
||||
throw my_exception() << info_errno(errno);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(
|
||||
my_exception & x )
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
|
||||
#include <boost/exception/get_error_info.hpp>
|
||||
#include <boost/exception/info_tuple.hpp>
|
||||
#include <boost/exception_ptr.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
@ -35,16 +36,6 @@ user_data
|
||||
}
|
||||
};
|
||||
|
||||
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
|
||||
struct tag_test_1 {};
|
||||
struct tag_test_2 {};
|
||||
struct tag_test_3 {};
|
||||
struct tag_test_4 {};
|
||||
struct tag_test_5 {};
|
||||
struct tag_test_6 {};
|
||||
struct tag_user_data {};
|
||||
#endif
|
||||
|
||||
typedef boost::error_info<struct tag_test_1,int> test_1;
|
||||
typedef boost::error_info<struct tag_test_2,unsigned int> test_2;
|
||||
typedef boost::error_info<struct tag_test_3,float> test_3;
|
||||
@ -312,13 +303,12 @@ test_add_tuple()
|
||||
}
|
||||
|
||||
void
|
||||
test_lifetime()
|
||||
test_lifetime1()
|
||||
{
|
||||
int count=0;
|
||||
try
|
||||
{
|
||||
throw test_exception() << test_7(user_data(count));
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(
|
||||
boost::exception & x )
|
||||
@ -334,6 +324,19 @@ test_lifetime()
|
||||
BOOST_TEST(!count);
|
||||
}
|
||||
|
||||
void
|
||||
test_lifetime2()
|
||||
{
|
||||
int count=0;
|
||||
{
|
||||
boost::exception_ptr ep;
|
||||
test_exception e; e<<test_7(user_data(count));
|
||||
ep=boost::copy_exception(e);
|
||||
BOOST_TEST(count>0);
|
||||
}
|
||||
BOOST_TEST(!count);
|
||||
}
|
||||
|
||||
bool
|
||||
is_const( int const * )
|
||||
{
|
||||
@ -365,7 +368,8 @@ main()
|
||||
test_basic_throw_catch();
|
||||
test_catch_add_info();
|
||||
test_add_tuple();
|
||||
test_lifetime();
|
||||
test_lifetime1();
|
||||
test_lifetime2();
|
||||
test_const();
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
112
test/exception_ptr_test.cpp
Normal file
112
test/exception_ptr_test.cpp
Normal file
@ -0,0 +1,112 @@
|
||||
//Copyright (c) 2006-2009 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_ptr.hpp>
|
||||
#include <boost/exception/info.hpp>
|
||||
#include <boost/exception/get_error_info.hpp>
|
||||
#include <boost/exception/diagnostic_information.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/thread.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
|
||||
class thread_handle;
|
||||
boost::shared_ptr<thread_handle> create_thread( boost::function<void()> const & f );
|
||||
void join( thread_handle & t );
|
||||
|
||||
class
|
||||
thread_handle
|
||||
{
|
||||
thread_handle( thread_handle const & );
|
||||
thread_handle & operator=( thread_handle const & );
|
||||
|
||||
boost::exception_ptr err_;
|
||||
boost::thread t_;
|
||||
|
||||
static
|
||||
void
|
||||
thread_wrapper( boost::function<void()> const & f, boost::exception_ptr & ep )
|
||||
{
|
||||
BOOST_ASSERT(!ep);
|
||||
try
|
||||
{
|
||||
f();
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
ep = boost::current_exception();
|
||||
}
|
||||
}
|
||||
|
||||
explicit
|
||||
thread_handle( boost::function<void()> const & f ):
|
||||
t_(boost::bind(thread_wrapper,f,err_))
|
||||
{
|
||||
}
|
||||
|
||||
friend boost::shared_ptr<thread_handle> create_thread( boost::function<void()> const & f );
|
||||
friend void join( thread_handle & t );
|
||||
};
|
||||
|
||||
boost::shared_ptr<thread_handle>
|
||||
create_thread( boost::function<void()> const & f )
|
||||
{
|
||||
boost::shared_ptr<thread_handle> t( new thread_handle(f) );
|
||||
return t;
|
||||
}
|
||||
|
||||
void
|
||||
join( thread_handle & t )
|
||||
{
|
||||
t.t_.join();
|
||||
if( t.err_ )
|
||||
rethrow_exception(t.err_);
|
||||
}
|
||||
|
||||
struct exc: boost::exception, std::exception { };
|
||||
typedef boost::error_info<struct answer_,int> answer;
|
||||
|
||||
void
|
||||
thread_func()
|
||||
{
|
||||
BOOST_THROW_EXCEPTION(exc() << answer(42));
|
||||
}
|
||||
|
||||
void
|
||||
check( boost::shared_ptr<thread_handle> const & t )
|
||||
{
|
||||
try
|
||||
{
|
||||
join(*t);
|
||||
}
|
||||
catch(
|
||||
exc & e )
|
||||
{
|
||||
int const * a = boost::get_error_info<answer>(e);
|
||||
BOOST_TEST(a && *a==42);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
try
|
||||
{
|
||||
std::vector< boost::shared_ptr<thread_handle> > threads;
|
||||
std::generate_n(std::inserter(threads,threads.end()),256,boost::bind(create_thread,thread_func));
|
||||
std::for_each(threads.begin(),threads.end(),check);
|
||||
return boost::report_errors();
|
||||
}
|
||||
catch(
|
||||
... )
|
||||
{
|
||||
std::cerr <<
|
||||
"Caught unexpected exception.\n"
|
||||
"Output from current_exception_diagnostic_information:\n" <<
|
||||
boost::current_exception_diagnostic_information() << std::endl;
|
||||
return 42;
|
||||
}
|
||||
}
|
||||
@ -4,7 +4,6 @@
|
||||
//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
|
||||
@ -31,11 +30,20 @@ n2
|
||||
}
|
||||
}
|
||||
|
||||
template <bool Test>
|
||||
struct test;
|
||||
|
||||
template <>
|
||||
struct
|
||||
test<true>
|
||||
{
|
||||
};
|
||||
|
||||
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<!boost::is_output_streamable<n1::c1>::value>();
|
||||
test<boost::is_output_streamable<n2::c2>::value>();
|
||||
test<boost::is_output_streamable<int>::value>();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -11,7 +11,18 @@
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <stdlib.h>
|
||||
|
||||
struct my_exception: boost::exception, std::exception { };
|
||||
struct
|
||||
my_exception:
|
||||
boost::exception,
|
||||
std::exception
|
||||
{
|
||||
char const *
|
||||
what() const throw()
|
||||
{
|
||||
return "my_exception";
|
||||
}
|
||||
};
|
||||
|
||||
typedef boost::error_info<struct my_tag,int> my_int;
|
||||
|
||||
bool called=false;
|
||||
@ -28,6 +39,7 @@ boost
|
||||
#ifndef BOOST_NO_RTTI
|
||||
BOOST_TEST(s.find("my_tag")!=std::string::npos);
|
||||
#endif
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -28,11 +28,16 @@ test_type
|
||||
++count_;
|
||||
}
|
||||
|
||||
void
|
||||
bool
|
||||
release()
|
||||
{
|
||||
if( !--count_ )
|
||||
if( --count_ )
|
||||
return false;
|
||||
else
|
||||
{
|
||||
delete this;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
@ -30,7 +30,7 @@ boost_throw_exception_test()
|
||||
try
|
||||
{
|
||||
BOOST_THROW_EXCEPTION(exception1());
|
||||
BOOST_TEST(false);
|
||||
BOOST_ERROR("BOOST_THROW_EXCEPTION failed to throw.");
|
||||
}
|
||||
catch(
|
||||
boost::exception & x )
|
||||
@ -50,7 +50,7 @@ boost_throw_exception_test()
|
||||
try
|
||||
{
|
||||
BOOST_THROW_EXCEPTION(exception2() << test_data(42));
|
||||
BOOST_TEST(false);
|
||||
BOOST_ERROR("BOOST_THROW_EXCEPTION failed to throw.");
|
||||
}
|
||||
catch(
|
||||
boost::exception & x )
|
||||
|
||||
Reference in New Issue
Block a user