mirror of
https://github.com/boostorg/system.git
synced 2025-07-30 12:37:13 +02:00
Reformat error_code.hpp
This commit is contained in:
Peter Dimov
@ -66,27 +66,33 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
|
||||
class error_code; // values defined by the operating system
|
||||
class error_condition; // portable generic values defined below, but ultimately
|
||||
namespace system
|
||||
{
|
||||
|
||||
class error_code; // values defined by the operating system
|
||||
class error_condition; // portable generic values defined below, but ultimately
|
||||
// based on the POSIX standard
|
||||
|
||||
// "Concept" helpers -------------------------------------------------------------//
|
||||
// "Concept" helpers -------------------------------------------------------------//
|
||||
|
||||
template< class T >
|
||||
struct is_error_code_enum { static const bool value = false; };
|
||||
template<class T> struct is_error_code_enum
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct is_error_condition_enum { static const bool value = false; };
|
||||
template<class T> struct is_error_condition_enum
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
// generic error_conditions ------------------------------------------------------//
|
||||
// generic error_conditions ------------------------------------------------------//
|
||||
|
||||
namespace errc
|
||||
{
|
||||
enum errc_t
|
||||
{
|
||||
namespace errc
|
||||
{
|
||||
|
||||
enum errc_t
|
||||
{
|
||||
success = 0,
|
||||
address_family_not_supported = EAFNOSUPPORT,
|
||||
address_in_use = EADDRINUSE,
|
||||
@ -166,50 +172,54 @@ namespace boost
|
||||
too_many_symbolic_link_levels = ELOOP,
|
||||
value_too_large = EOVERFLOW,
|
||||
wrong_protocol_type = EPROTOTYPE
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace errc
|
||||
} // namespace errc
|
||||
|
||||
# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
|
||||
namespace posix = errc;
|
||||
namespace posix_error = errc;
|
||||
# endif
|
||||
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
|
||||
|
||||
template<> struct is_error_condition_enum<errc::errc_t>
|
||||
{ static const bool value = true; };
|
||||
namespace posix = errc;
|
||||
namespace posix_error = errc;
|
||||
|
||||
#endif
|
||||
|
||||
template<> struct is_error_condition_enum<errc::errc_t>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
|
||||
// --------------------------------------------------------------------------------//
|
||||
// --------------------------------------------------------------------------------//
|
||||
|
||||
// Operating system specific interfaces ------------------------------------------//
|
||||
// Operating system specific interfaces ------------------------------------------//
|
||||
|
||||
|
||||
// The interface is divided into general and system-specific portions to
|
||||
// meet these requirements:
|
||||
//
|
||||
// * Code calling an operating system API can create an error_code with
|
||||
// a single category (system_category), even for POSIX-like operating
|
||||
// systems that return some POSIX errno values and some native errno
|
||||
// values. This code should not have to pay the cost of distinguishing
|
||||
// between categories, since it is not yet known if that is needed.
|
||||
//
|
||||
// * Users wishing to write system-specific code should be given enums for
|
||||
// at least the common error cases.
|
||||
//
|
||||
// * System specific code should fail at compile time if moved to another
|
||||
// operating system.
|
||||
// The interface is divided into general and system-specific portions to
|
||||
// meet these requirements:
|
||||
//
|
||||
// * Code calling an operating system API can create an error_code with
|
||||
// a single category (system_category), even for POSIX-like operating
|
||||
// systems that return some POSIX errno values and some native errno
|
||||
// values. This code should not have to pay the cost of distinguishing
|
||||
// between categories, since it is not yet known if that is needed.
|
||||
//
|
||||
// * Users wishing to write system-specific code should be given enums for
|
||||
// at least the common error cases.
|
||||
//
|
||||
// * System specific code should fail at compile time if moved to another
|
||||
// operating system.
|
||||
|
||||
// The system specific portions of the interface are located in headers
|
||||
// with names reflecting the operating system. For example,
|
||||
//
|
||||
// <boost/system/cygwin_error.hpp>
|
||||
// <boost/system/linux_error.hpp>
|
||||
// <boost/system/windows_error.hpp>
|
||||
//
|
||||
// These headers are effectively empty for compiles on operating systems
|
||||
// where they are not applicable.
|
||||
// The system specific portions of the interface are located in headers
|
||||
// with names reflecting the operating system. For example,
|
||||
//
|
||||
// <boost/system/cygwin_error.hpp>
|
||||
// <boost/system/linux_error.hpp>
|
||||
// <boost/system/windows_error.hpp>
|
||||
//
|
||||
// These headers are effectively empty for compiles on operating systems
|
||||
// where they are not applicable.
|
||||
|
||||
// --------------------------------------------------------------------------------//
|
||||
// --------------------------------------------------------------------------------//
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
@ -217,13 +227,13 @@ namespace boost
|
||||
#pragma warning(disable: 4355)
|
||||
#endif
|
||||
|
||||
// class error_category ------------------------------------------------//
|
||||
// class error_category ------------------------------------------------//
|
||||
|
||||
class error_category : public noncopyable
|
||||
{
|
||||
class error_category: public noncopyable
|
||||
{
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
private:
|
||||
private:
|
||||
|
||||
class std_category: public std::error_category
|
||||
{
|
||||
@ -247,19 +257,15 @@ namespace boost
|
||||
return pc_->message( ev );
|
||||
}
|
||||
|
||||
virtual std::error_condition default_error_condition( int ev ) const
|
||||
BOOST_NOEXCEPT;
|
||||
virtual bool equivalent( int code, const std::error_condition & condition ) const
|
||||
BOOST_NOEXCEPT;
|
||||
virtual bool equivalent( const std::error_code & code, int condition ) const
|
||||
BOOST_NOEXCEPT;
|
||||
virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
|
||||
|
||||
virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT;
|
||||
virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
|
||||
};
|
||||
|
||||
std_category std_cat_;
|
||||
|
||||
public:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
|
||||
public:
|
||||
|
||||
operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
@ -271,10 +277,10 @@ namespace boost
|
||||
|
||||
#else
|
||||
|
||||
// to maintain ABI compatibility between 03 and 11,
|
||||
// define a class with the same layout
|
||||
// to maintain ABI compatibility between 03 and 11,
|
||||
// define a class with the same layout
|
||||
|
||||
private:
|
||||
private:
|
||||
|
||||
class std_category
|
||||
{
|
||||
@ -308,43 +314,47 @@ namespace boost
|
||||
|
||||
std_category std_cat_;
|
||||
|
||||
public:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
|
||||
|
||||
#endif
|
||||
|
||||
public:
|
||||
virtual ~error_category(){}
|
||||
public:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this )
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~error_category()
|
||||
{
|
||||
}
|
||||
|
||||
virtual const char * name() const BOOST_SYSTEM_NOEXCEPT = 0;
|
||||
|
||||
virtual std::string message( int ev ) const = 0;
|
||||
inline virtual error_condition default_error_condition( int ev ) const
|
||||
BOOST_SYSTEM_NOEXCEPT;
|
||||
inline virtual bool equivalent( int code,
|
||||
const error_condition & condition ) const
|
||||
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,
|
||||
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return &lhs == &rhs; }
|
||||
inline virtual error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
|
||||
inline virtual bool equivalent( int code, const error_condition & condition ) const 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,
|
||||
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return &lhs != &rhs; }
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator==( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return &lhs == &rhs;
|
||||
}
|
||||
|
||||
inline bool operator<( const error_category & lhs,
|
||||
const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return std::less<const error_category*>()( &lhs, &rhs ); }
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return &lhs != &rhs;
|
||||
}
|
||||
|
||||
inline bool operator<( const error_category & lhs, const error_category & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return std::less<const error_category*>()( &lhs, &rhs );
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// predefined error categories ---------------------------------------------------//
|
||||
// predefined error categories ---------------------------------------------------//
|
||||
|
||||
namespace detail
|
||||
{
|
||||
@ -499,39 +509,41 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
|
||||
#endif
|
||||
|
||||
// deprecated synonyms ------------------------------------------------------------//
|
||||
// deprecated synonyms ------------------------------------------------------------//
|
||||
|
||||
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
|
||||
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_posix_category() { return generic_category(); }
|
||||
static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED
|
||||
= generic_category();
|
||||
static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED
|
||||
= generic_category();
|
||||
static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED
|
||||
= 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_posix_category() { return generic_category(); }
|
||||
static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED = generic_category();
|
||||
static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED = generic_category();
|
||||
static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED = system_category();
|
||||
|
||||
#endif
|
||||
|
||||
// class error_condition ---------------------------------------------------------//
|
||||
// class error_condition ---------------------------------------------------------//
|
||||
|
||||
// error_conditions are portable, error_codes are system or library specific
|
||||
// error_conditions are portable, error_codes are system or library specific
|
||||
|
||||
class error_condition
|
||||
{
|
||||
public:
|
||||
class error_condition
|
||||
{
|
||||
public:
|
||||
|
||||
// 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>
|
||||
error_condition(ErrorConditionEnum e,
|
||||
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value>::type*
|
||||
= 0) BOOST_SYSTEM_NOEXCEPT
|
||||
BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_SYSTEM_NOEXCEPT: m_val( 0 ), m_cat( &generic_category() )
|
||||
{
|
||||
*this = make_error_condition(e);
|
||||
}
|
||||
|
||||
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 );
|
||||
}
|
||||
|
||||
// modifiers:
|
||||
@ -543,11 +555,10 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
}
|
||||
|
||||
template<typename ErrorConditionEnum>
|
||||
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value,
|
||||
error_condition>::type &
|
||||
typename boost::enable_if_<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
|
||||
operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
*this = make_error_condition(val);
|
||||
*this = make_error_condition( val );
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -558,9 +569,21 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
}
|
||||
|
||||
// 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; }
|
||||
std::string message() const { return m_cat->message(value()); }
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
std::string message() const
|
||||
{
|
||||
return m_cat->message( value() );
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
|
||||
|
||||
@ -589,19 +612,15 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
// relationals:
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// 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;
|
||||
}
|
||||
|
||||
inline friend bool operator<( const error_condition & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return lhs.m_cat < rhs.m_cat
|
||||
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
|
||||
return lhs.m_cat < rhs.m_cat || ( lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val );
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
@ -613,38 +632,43 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
private:
|
||||
|
||||
int m_val;
|
||||
const error_category * m_cat;
|
||||
};
|
||||
|
||||
};
|
||||
// class error_code --------------------------------------------------------------//
|
||||
|
||||
// class error_code --------------------------------------------------------------//
|
||||
// We want error_code to be a value type that can be copied without slicing
|
||||
// and without requiring heap allocation, but we also want it to have
|
||||
// polymorphic behavior based on the error category. This is achieved by
|
||||
// abstract base class error_category supplying the polymorphic behavior,
|
||||
// and error_code containing a pointer to an object of a type derived
|
||||
// from error_category.
|
||||
|
||||
// We want error_code to be a value type that can be copied without slicing
|
||||
// and without requiring heap allocation, but we also want it to have
|
||||
// polymorphic behavior based on the error category. This is achieved by
|
||||
// abstract base class error_category supplying the polymorphic behavior,
|
||||
// and error_code containing a pointer to an object of a type derived
|
||||
// from error_category.
|
||||
class error_code
|
||||
{
|
||||
public:
|
||||
class error_code
|
||||
{
|
||||
public:
|
||||
|
||||
// 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>
|
||||
error_code(ErrorCodeEnum e,
|
||||
typename boost::enable_if_<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0)
|
||||
BOOST_SYSTEM_NOEXCEPT
|
||||
BOOST_SYSTEM_CONSTEXPR error_code() BOOST_SYSTEM_NOEXCEPT: m_val( 0 ), m_cat( &system_category() )
|
||||
{
|
||||
*this = make_error_code(e);
|
||||
}
|
||||
|
||||
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 );
|
||||
}
|
||||
|
||||
// modifiers:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
m_val = val;
|
||||
@ -655,7 +679,7 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
typename boost::enable_if_<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
|
||||
operator=( ErrorCodeEnum val ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
*this = make_error_code(val);
|
||||
*this = make_error_code( val );
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -666,11 +690,26 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
}
|
||||
|
||||
// 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
|
||||
{ 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)
|
||||
|
||||
@ -697,21 +736,18 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
#endif
|
||||
|
||||
// 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
|
||||
// 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;
|
||||
}
|
||||
|
||||
inline friend bool operator<( const error_code & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return lhs.m_cat < rhs.m_cat
|
||||
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
|
||||
return lhs.m_cat < rhs.m_cat || ( lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val );
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
@ -723,34 +759,39 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
private:
|
||||
|
||||
int m_val;
|
||||
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
|
||||
BOOST_SYSTEM_DECL extern error_code throws;
|
||||
# endif
|
||||
#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
|
||||
|
||||
// Moving from a "throws" object to a "throws" function without breaking
|
||||
// existing code is a bit of a problem. The workaround is to place the
|
||||
// "throws" function in namespace boost rather than namespace boost::system.
|
||||
BOOST_SYSTEM_DECL extern error_code throws;
|
||||
|
||||
} // namespace system
|
||||
#endif
|
||||
|
||||
namespace detail
|
||||
{
|
||||
// Misuse of the error_code object is turned into a noisy failure by
|
||||
// poisoning the reference. This particular implementation doesn't
|
||||
// produce warnings or errors from popular compilers, is very efficient
|
||||
// (as determined by inspecting generated code), and does not suffer
|
||||
// from order of initialization problems. In practice, it also seems
|
||||
// cause user function error handling implementation errors to be detected
|
||||
// very early in the development cycle.
|
||||
inline system::error_code* throws()
|
||||
{
|
||||
// Moving from a "throws" object to a "throws" function without breaking
|
||||
// existing code is a bit of a problem. The workaround is to place the
|
||||
// "throws" function in namespace boost rather than namespace boost::system.
|
||||
|
||||
} // namespace system
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
// Misuse of the error_code object is turned into a noisy failure by
|
||||
// poisoning the reference. This particular implementation doesn't
|
||||
// produce warnings or errors from popular compilers, is very efficient
|
||||
// (as determined by inspecting generated code), and does not suffer
|
||||
// from order of initialization problems. In practice, it also seems
|
||||
// cause user function error handling implementation errors to be detected
|
||||
// very early in the development cycle.
|
||||
|
||||
inline system::error_code* throws()
|
||||
{
|
||||
// See github.com/boostorg/system/pull/12 by visigoth for why the return
|
||||
// is poisoned with nonzero rather than (0). A test, test_throws_usage(),
|
||||
// has been added to error_code_test.cpp, and as visigoth mentioned it
|
||||
@ -759,166 +800,159 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
// Since the undefined behavior sanitizer (-fsanitize=undefined) does not
|
||||
// allow a reference to be formed to the unaligned address of (1), we use
|
||||
// (8) instead.
|
||||
|
||||
return reinterpret_cast<system::error_code*>(8);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline system::error_code& throws()
|
||||
{ return *detail::throws(); }
|
||||
} // namespace detail
|
||||
|
||||
namespace system
|
||||
{
|
||||
// non-member functions ------------------------------------------------//
|
||||
inline system::error_code& throws()
|
||||
{
|
||||
return *detail::throws();
|
||||
}
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
namespace system
|
||||
{
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
// non-member functions ------------------------------------------------//
|
||||
|
||||
inline bool operator==( const error_code & code,
|
||||
const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return code.category().equivalent( code.value(), condition )
|
||||
|| condition.category().equivalent( code, condition.value() );
|
||||
}
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
|
||||
inline bool operator!=( const error_code & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
|
||||
inline bool operator==( const error_condition & condition,
|
||||
const error_code & code ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return condition.category().equivalent( code, condition.value() )
|
||||
|| code.category().equivalent( code.value(), condition );
|
||||
}
|
||||
inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
|
||||
}
|
||||
|
||||
inline bool operator!=( const error_condition & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
|
||||
// TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
|
||||
inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition );
|
||||
}
|
||||
|
||||
template <class charT, class traits>
|
||||
inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
|
||||
template <class charT, class traits>
|
||||
inline std::basic_ostream<charT,traits>&
|
||||
operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
|
||||
{
|
||||
{
|
||||
os << ec.category().name() << ':' << ec.value();
|
||||
return os;
|
||||
}
|
||||
}
|
||||
|
||||
inline std::size_t hash_value( const error_code & ec )
|
||||
{
|
||||
return static_cast<std::size_t>(ec.value())
|
||||
+ reinterpret_cast<std::size_t>(&ec.category());
|
||||
}
|
||||
inline std::size_t hash_value( const error_code & ec )
|
||||
{
|
||||
return static_cast<std::size_t>( ec.value() ) + reinterpret_cast<std::size_t>( &ec.category() );
|
||||
}
|
||||
|
||||
// make_* functions for errc::errc_t ---------------------------------------------//
|
||||
// make_* functions for errc::errc_t ---------------------------------------------//
|
||||
|
||||
namespace errc
|
||||
{
|
||||
// explicit conversion:
|
||||
inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return error_code( e, generic_category() ); }
|
||||
namespace errc
|
||||
{
|
||||
|
||||
// implicit conversion:
|
||||
inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return error_condition( e, generic_category() ); }
|
||||
}
|
||||
// explicit conversion:
|
||||
inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return error_code( e, generic_category() );
|
||||
}
|
||||
|
||||
// error_category default implementation -----------------------------------------//
|
||||
// implicit conversion:
|
||||
inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return error_condition( e, generic_category() );
|
||||
}
|
||||
|
||||
error_condition error_category::default_error_condition( int ev ) const
|
||||
BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
} // namespace errc
|
||||
|
||||
// error_category default implementation -----------------------------------------//
|
||||
|
||||
error_condition error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return error_condition( ev, *this );
|
||||
}
|
||||
}
|
||||
|
||||
bool error_category::equivalent( int code,
|
||||
const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
bool error_category::equivalent( int code, const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
}
|
||||
|
||||
bool error_category::equivalent( const error_code & code,
|
||||
int condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
bool error_category::equivalent( const error_code & code, int condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return *this == code.category() && code.value() == condition;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
inline std::error_condition error_category::std_category::default_error_condition(
|
||||
int ev ) const BOOST_NOEXCEPT
|
||||
{
|
||||
inline std::error_condition error_category::std_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
|
||||
{
|
||||
return pc_->default_error_condition( ev );
|
||||
}
|
||||
}
|
||||
|
||||
inline bool error_category::std_category::equivalent( int code,
|
||||
const std::error_condition & condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
inline bool error_category::std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( condition.category() == *this )
|
||||
{
|
||||
boost::system::error_condition bn( condition.value(), *pc_ );
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
else if( condition.category() == std::generic_category()
|
||||
|| condition.category() == boost::system::generic_category() )
|
||||
else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
|
||||
{
|
||||
boost::system::error_condition bn( condition.value(),
|
||||
boost::system::generic_category() );
|
||||
|
||||
boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
|
||||
#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_ );
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
else
|
||||
{
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline bool error_category::std_category::equivalent( const std::error_code & code,
|
||||
int condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
inline bool error_category::std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( code.category() == *this )
|
||||
{
|
||||
boost::system::error_code bc( code.value(), *pc_ );
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
else if( code.category() == std::generic_category()
|
||||
|| code.category() == boost::system::generic_category() )
|
||||
else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
|
||||
{
|
||||
boost::system::error_code bc( code.value(),
|
||||
boost::system::generic_category() );
|
||||
|
||||
boost::system::error_code bc( code.value(), boost::system::generic_category() );
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
|
||||
#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_ );
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
#endif
|
||||
|
||||
else if( *pc_ == boost::system::generic_category() )
|
||||
{
|
||||
return std::generic_category().equivalent( code, condition );
|
||||
@ -927,17 +961,18 @@ inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif // #ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
} // namespace system
|
||||
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
|
||||
|
||||
# ifdef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
#ifdef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
# include <boost/system/detail/error_code.ipp>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif // BOOST_SYSTEM_ERROR_CODE_HPP
|
||||
|
||||
Reference in New Issue
Block a user