feedc0de/boost_system
1
0
Fork 0
forked from boostorg/system
Code Pull Requests Activity

Reformat error_code.hpp

Browse Source
This commit is contained in:
Peter Dimov
2018-09-15 20:05:10 +03:00
parent f92c0fc9b7
commit 736d618120
1 changed files with 533 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
include/boost/system/error_code.hpp
View File

@@ -66,6 +66,7 @@
namespace boost namespace boost
{ {
namespace system namespace system
{ {
@@ -75,16 +76,21 @@ namespace boost
// "Concept" helpers -------------------------------------------------------------// // "Concept" helpers -------------------------------------------------------------//
template< class T > template<class T> struct is_error_code_enum
struct is_error_code_enum { static const bool value = false; }; {
static const bool value = false;
};
template< class T > template<class T> struct is_error_condition_enum
struct is_error_condition_enum { static const bool value = false; }; {
static const bool value = false;
};
// generic error_conditions ------------------------------------------------------// // generic error_conditions ------------------------------------------------------//
namespace errc namespace errc
{ {
enum errc_t enum errc_t
{ {
success = 0, success = 0,
@@ -171,12 +177,16 @@ namespace boost
} // namespace errc } // namespace errc
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED #ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
namespace posix = errc; namespace posix = errc;
namespace posix_error = errc; namespace posix_error = errc;
#endif #endif
template<> struct is_error_condition_enum<errc::errc_t> template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; }; {
static const bool value = true;
};
// --------------------------------------------------------------------------------// // --------------------------------------------------------------------------------//
@@ -247,20 +257,16 @@ namespace boost
return pc_->message( ev ); return pc_->message( ev );
} }
virtual std::error_condition default_error_condition( int ev ) const virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
BOOST_NOEXCEPT;
virtual bool equivalent( int code, const std::error_condition & condition ) const virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT;
BOOST_NOEXCEPT; virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
virtual bool equivalent( const std::error_code & code, int condition ) const
BOOST_NOEXCEPT;
}; };
std_category std_cat_; std_category std_cat_;
public: public:
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT
{ {
// do not map generic to std::generic on purpose; occasionally, // do not map generic to std::generic on purpose; occasionally,
@@ -308,37 +314,41 @@ namespace boost
std_category std_cat_; std_category std_cat_;
public:
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
#endif #endif
public: public:
virtual ~error_category(){}
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this )
{
}
virtual ~error_category()
{
}
virtual const char * name() const BOOST_SYSTEM_NOEXCEPT = 0; virtual const char * name() const BOOST_SYSTEM_NOEXCEPT = 0;
virtual std::string message( int ev ) const = 0; virtual std::string message( int ev ) const = 0;
inline virtual error_condition default_error_condition( int ev ) const
BOOST_SYSTEM_NOEXCEPT; inline virtual error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
inline virtual bool equivalent( int code, inline virtual bool equivalent( int code, const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT;
const error_condition & condition ) const inline virtual bool equivalent( const error_code & code, int condition ) const BOOST_SYSTEM_NOEXCEPT;
BOOST_SYSTEM_NOEXCEPT;
inline virtual bool equivalent( const error_code & code,
int condition ) const BOOST_SYSTEM_NOEXCEPT;
}; };
BOOST_SYSTEM_CONSTEXPR inline bool operator==( const error_category & lhs, BOOST_SYSTEM_CONSTEXPR inline bool operator==( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT {
{ return &lhs == &rhs; } return &lhs == &rhs;
}
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_category & lhs, BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT {
{ return &lhs != &rhs; } return &lhs != &rhs;
}
inline bool operator<( const error_category & lhs, inline bool operator<( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT {
{ return std::less<const error_category*>()( &lhs, &rhs ); } return std::less<const error_category*>()( &lhs, &rhs );
}
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
#pragma warning(pop) #pragma warning(pop)
@@ -502,15 +512,14 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
// deprecated synonyms ------------------------------------------------------------// // deprecated synonyms ------------------------------------------------------------//
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED #ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
inline const error_category & get_system_category() { return system_category(); } inline const error_category & get_system_category() { return system_category(); }
inline const error_category & get_generic_category() { return generic_category(); } inline const error_category & get_generic_category() { return generic_category(); }
inline const error_category & get_posix_category() { return generic_category(); } inline const error_category & get_posix_category() { return generic_category(); }
static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED = generic_category();
= generic_category(); static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED = generic_category();
static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED = system_category();
= generic_category();
static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED
= system_category();
#endif #endif
// class error_condition ---------------------------------------------------------// // class error_condition ---------------------------------------------------------//
@@ -522,14 +531,17 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
public: public:
// constructors: // constructors:
BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&generic_category()) {}
BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
: m_val(val), m_cat(&cat) {}
template <class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_SYSTEM_NOEXCEPT: m_val( 0 ), m_cat( &generic_category() )
error_condition(ErrorConditionEnum e, {
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value>::type* }
= 0) BOOST_SYSTEM_NOEXCEPT
BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT: m_val( val ), m_cat( &cat )
{
}
template<class ErrorConditionEnum> error_condition( ErrorConditionEnum e,
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value>::type* = 0) BOOST_SYSTEM_NOEXCEPT
{ {
*this = make_error_condition( e ); *this = make_error_condition( e );
} }
@@ -543,8 +555,7 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
} }
template<typename ErrorConditionEnum> template<typename ErrorConditionEnum>
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value, typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
error_condition>::type &
operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT
{ {
*this = make_error_condition( val ); *this = make_error_condition( val );
@@ -558,9 +569,21 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
} }
// observers: // observers:
BOOST_SYSTEM_CONSTEXPR int value() const BOOST_SYSTEM_NOEXCEPT { return m_val; }
BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; } BOOST_SYSTEM_CONSTEXPR int value() const BOOST_SYSTEM_NOEXCEPT
std::string message() const { return m_cat->message(value()); } {
return m_val;
}
BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_SYSTEM_NOEXCEPT
{
return *m_cat;
}
std::string message() const
{
return m_cat->message( value() );
}
#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
@@ -589,19 +612,15 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
// relationals: // relationals:
// the more symmetrical non-member syntax allows enum // the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs. // conversions work for both rhs and lhs.
BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs,
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val; return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
} }
inline friend bool operator<( const error_condition & lhs, inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
{ {
return lhs.m_cat < rhs.m_cat return lhs.m_cat < rhs.m_cat || ( lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val );
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
} }
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR #ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
@@ -614,9 +633,9 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
#endif #endif
private: private:
int m_val; int m_val;
const error_category * m_cat; const error_category * m_cat;
}; };
// class error_code --------------------------------------------------------------// // class error_code --------------------------------------------------------------//
@@ -627,24 +646,29 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
// abstract base class error_category supplying the polymorphic behavior, // abstract base class error_category supplying the polymorphic behavior,
// and error_code containing a pointer to an object of a type derived // and error_code containing a pointer to an object of a type derived
// from error_category. // from error_category.
class error_code class error_code
{ {
public: public:
// constructors: // constructors:
BOOST_SYSTEM_CONSTEXPR error_code() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&system_category()) {}
BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
: m_val(val), m_cat(&cat) {}
template <class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code() BOOST_SYSTEM_NOEXCEPT: m_val( 0 ), m_cat( &system_category() )
error_code(ErrorCodeEnum e, {
typename boost::enable_if_<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0) }
BOOST_SYSTEM_NOEXCEPT
BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT: m_val( val ), m_cat( &cat )
{
}
template <class ErrorCodeEnum> error_code( ErrorCodeEnum e,
typename boost::enable_if_<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_SYSTEM_NOEXCEPT
{ {
*this = make_error_code( e ); *this = make_error_code( e );
} }
// modifiers: // modifiers:
BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
{ {
m_val = val; m_val = val;
@@ -666,11 +690,26 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
} }
// observers: // observers:
BOOST_SYSTEM_CONSTEXPR int value() const BOOST_SYSTEM_NOEXCEPT { return m_val; }
BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; } BOOST_SYSTEM_CONSTEXPR int value() const BOOST_SYSTEM_NOEXCEPT
{
return m_val;
}
BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_SYSTEM_NOEXCEPT
{
return *m_cat;
}
error_condition default_error_condition() const BOOST_SYSTEM_NOEXCEPT error_condition default_error_condition() const BOOST_SYSTEM_NOEXCEPT
{ return m_cat->default_error_condition(value()); } {
std::string message() const { return m_cat->message(value()); } return m_cat->default_error_condition(value());
}
std::string message() const
{
return m_cat->message( value() );
}
#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
@@ -697,21 +736,18 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
#endif #endif
// relationals: // relationals:
BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs,
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
// the more symmetrical non-member syntax allows enum // the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs. // conversions work for both rhs and lhs.
BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val; return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
} }
inline friend bool operator<( const error_code & lhs, inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
{ {
return lhs.m_cat < rhs.m_cat return lhs.m_cat < rhs.m_cat || ( lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val );
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
} }
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR #ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
@@ -724,14 +760,17 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
#endif #endif
private: private:
int m_val; int m_val;
const error_category * m_cat; const error_category * m_cat;
}; };
// predefined error_code object used as "throw on error" tag // predefined error_code object used as "throw on error" tag
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED #ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
BOOST_SYSTEM_DECL extern error_code throws; BOOST_SYSTEM_DECL extern error_code throws;
#endif #endif
// Moving from a "throws" object to a "throws" function without breaking // Moving from a "throws" object to a "throws" function without breaking
@@ -742,6 +781,7 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
namespace detail namespace detail
{ {
// Misuse of the error_code object is turned into a noisy failure by // Misuse of the error_code object is turned into a noisy failure by
// poisoning the reference. This particular implementation doesn't // poisoning the reference. This particular implementation doesn't
// produce warnings or errors from popular compilers, is very efficient // produce warnings or errors from popular compilers, is very efficient
@@ -749,6 +789,7 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
// from order of initialization problems. In practice, it also seems // from order of initialization problems. In practice, it also seems
// cause user function error handling implementation errors to be detected // cause user function error handling implementation errors to be detected
// very early in the development cycle. // very early in the development cycle.
inline system::error_code* throws() inline system::error_code* throws()
{ {
// See github.com/boostorg/system/pull/12 by visigoth for why the return // See github.com/boostorg/system/pull/12 by visigoth for why the return
@@ -759,57 +800,52 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
// Since the undefined behavior sanitizer (-fsanitize=undefined) does not // Since the undefined behavior sanitizer (-fsanitize=undefined) does not
// allow a reference to be formed to the unaligned address of (1), we use // allow a reference to be formed to the unaligned address of (1), we use
// (8) instead. // (8) instead.
return reinterpret_cast<system::error_code*>(8); return reinterpret_cast<system::error_code*>(8);
} }
}
} // namespace detail
inline system::error_code& throws() inline system::error_code& throws()
{ return *detail::throws(); } {
return *detail::throws();
}
namespace system namespace system
{ {
// non-member functions ------------------------------------------------// // non-member functions ------------------------------------------------//
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs, BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return !( lhs == rhs ); return !( lhs == rhs );
} }
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs, BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return !( lhs == rhs ); return !( lhs == rhs );
} }
inline bool operator==( const error_code & code, inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
{ {
return code.category().equivalent( code.value(), condition ) return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
|| condition.category().equivalent( code, condition.value() );
} }
inline bool operator!=( const error_code & lhs, inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return !( lhs == rhs ); return !( lhs == rhs );
} }
inline bool operator==( const error_condition & condition, inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_SYSTEM_NOEXCEPT
const error_code & code ) BOOST_SYSTEM_NOEXCEPT
{ {
return condition.category().equivalent( code, condition.value() ) return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition );
|| code.category().equivalent( code.value(), condition );
} }
inline bool operator!=( const error_condition & lhs, inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
{ {
return !( lhs == rhs ); return !( lhs == rhs );
} }
// TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
template <class charT, class traits> template <class charT, class traits>
inline std::basic_ostream<charT,traits>& inline std::basic_ostream<charT,traits>&
operator<< (std::basic_ostream<charT,traits>& os, error_code ec) operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
@@ -820,105 +856,103 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
inline std::size_t hash_value( const error_code & ec ) inline std::size_t hash_value( const error_code & ec )
{ {
return static_cast<std::size_t>(ec.value()) return static_cast<std::size_t>( ec.value() ) + reinterpret_cast<std::size_t>( &ec.category() );
+ reinterpret_cast<std::size_t>(&ec.category());
} }
// make_* functions for errc::errc_t ---------------------------------------------// // make_* functions for errc::errc_t ---------------------------------------------//
namespace errc namespace errc
{ {
// explicit conversion: // explicit conversion:
inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
{ return error_code( e, generic_category() ); } {
return error_code( e, generic_category() );
}
// implicit conversion: // implicit conversion:
inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
{ return error_condition( e, generic_category() ); } {
return error_condition( e, generic_category() );
} }
} // namespace errc
// error_category default implementation -----------------------------------------// // error_category default implementation -----------------------------------------//
error_condition error_category::default_error_condition( int ev ) const error_condition error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
BOOST_SYSTEM_NOEXCEPT
{ {
return error_condition( ev, *this ); return error_condition( ev, *this );
} }
bool error_category::equivalent( int code, bool error_category::equivalent( int code, const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
{ {
return default_error_condition( code ) == condition; return default_error_condition( code ) == condition;
} }
bool error_category::equivalent( const error_code & code, bool error_category::equivalent( const error_code & code, int condition ) const BOOST_SYSTEM_NOEXCEPT
int condition ) const BOOST_SYSTEM_NOEXCEPT
{ {
return *this == code.category() && code.value() == condition; return *this == code.category() && code.value() == condition;
} }
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR #ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
inline std::error_condition error_category::std_category::default_error_condition( inline std::error_condition error_category::std_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
int ev ) const BOOST_NOEXCEPT
{ {
return pc_->default_error_condition( ev ); return pc_->default_error_condition( ev );
} }
inline bool error_category::std_category::equivalent( int code, inline bool error_category::std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
const std::error_condition & condition ) const BOOST_NOEXCEPT
{ {
if( condition.category() == *this ) if( condition.category() == *this )
{ {
boost::system::error_condition bn( condition.value(), *pc_ ); boost::system::error_condition bn( condition.value(), *pc_ );
return pc_->equivalent( code, bn ); return pc_->equivalent( code, bn );
} }
else if( condition.category() == std::generic_category() else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
|| condition.category() == boost::system::generic_category() )
{ {
boost::system::error_condition bn( condition.value(), boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
boost::system::generic_category() );
return pc_->equivalent( code, bn ); return pc_->equivalent( code, bn );
} }
#ifndef BOOST_NO_RTTI #ifndef BOOST_NO_RTTI
else if( std_category const* pc2 = dynamic_cast< std_category const* >(
&condition.category() ) ) else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
{ {
boost::system::error_condition bn( condition.value(), *pc2->pc_ ); boost::system::error_condition bn( condition.value(), *pc2->pc_ );
return pc_->equivalent( code, bn ); return pc_->equivalent( code, bn );
} }
#endif #endif
else else
{ {
return default_error_condition( code ) == condition; return default_error_condition( code ) == condition;
} }
} }
inline bool error_category::std_category::equivalent( const std::error_code & code, inline bool error_category::std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
int condition ) const BOOST_NOEXCEPT
{ {
if( code.category() == *this ) if( code.category() == *this )
{ {
boost::system::error_code bc( code.value(), *pc_ ); boost::system::error_code bc( code.value(), *pc_ );
return pc_->equivalent( bc, condition ); return pc_->equivalent( bc, condition );
} }
else if( code.category() == std::generic_category() else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
|| code.category() == boost::system::generic_category() )
{ {
boost::system::error_code bc( code.value(), boost::system::error_code bc( code.value(), boost::system::generic_category() );
boost::system::generic_category() );
return pc_->equivalent( bc, condition ); return pc_->equivalent( bc, condition );
} }
#ifndef BOOST_NO_RTTI #ifndef BOOST_NO_RTTI
else if( std_category const* pc2 = dynamic_cast< std_category const* >(
&code.category() ) ) else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
{ {
boost::system::error_code bc( code.value(), *pc2->pc_ ); boost::system::error_code bc( code.value(), *pc2->pc_ );
return pc_->equivalent( bc, condition ); return pc_->equivalent( bc, condition );
} }
#endif #endif
else if( *pc_ == boost::system::generic_category() ) else if( *pc_ == boost::system::generic_category() )
{ {
return std::generic_category().equivalent( code, condition ); return std::generic_category().equivalent( code, condition );
@@ -929,9 +963,10 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
} }
} }
#endif #endif // #ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
} // namespace system } // namespace system
} // namespace boost } // namespace boost
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas