// -*- C++ -*- // Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/system_error * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_SYSTEM_ERROR #define _GLIBCXX_SYSTEM_ERROR 1 #pragma GCC system_header #ifndef __GXX_EXPERIMENTAL_CXX0X__ # include #else #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION class error_code; class error_condition; class error_category; class system_error; /// is_error_code_enum template struct is_error_code_enum : public false_type { }; /// is_error_condition_enum template struct is_error_condition_enum : public false_type { }; template<> struct is_error_condition_enum : public true_type { }; /// error_category class error_category { protected: error_category(); public: virtual ~error_category(); error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; virtual const char* name() const = 0; virtual string message(int) const = 0; virtual error_condition default_error_condition(int __i) const; virtual bool equivalent(int __i, const error_condition& __cond) const; virtual bool equivalent(const error_code& __code, int __i) const; bool operator<(const error_category& __other) const { return less()(this, &__other); } bool operator==(const error_category& __other) const { return this == &__other; } bool operator!=(const error_category& __other) const { return this != &__other; } }; // DR 890. _GLIBCXX_CONST const error_category& system_category() throw(); _GLIBCXX_CONST const error_category& generic_category() throw(); error_code make_error_code(errc); template struct hash; /// error_code // Implementation-specific error identification struct error_code { error_code() : _M_value(0), _M_cat(&system_category()) { } error_code(int __v, const error_category& __cat) : _M_value(__v), _M_cat(&__cat) { } template error_code(_ErrorCodeEnum __e, typename enable_if::value>::type* = 0) { *this = make_error_code(__e); } void assign(int __v, const error_category& __cat) { _M_value = __v; _M_cat = &__cat; } void clear() { assign(0, system_category()); } // DR 804. template typename enable_if::value, error_code&>::type operator=(_ErrorCodeEnum __e) { return *this = make_error_code(__e); } int value() const { return _M_value; } const error_category& category() const { return *_M_cat; } error_condition default_error_condition() const; string message() const { return category().message(value()); } explicit operator bool() const { return _M_value != 0 ? true : false; } // DR 804. private: friend class hash; int _M_value; const error_category* _M_cat; }; // 19.4.2.6 non-member functions inline error_code make_error_code(errc __e) { return error_code(static_cast(__e), generic_category()); } inline bool operator<(const error_code& __lhs, const error_code& __rhs) { return (__lhs.category() < __rhs.category() || (__lhs.category() == __rhs.category() && __lhs.value() < __rhs.value())); } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) { return (__os << __e.category().name() << ':' << __e.value()); } error_condition make_error_condition(errc); /// error_condition // Portable error identification struct error_condition { error_condition() : _M_value(0), _M_cat(&generic_category()) { } error_condition(int __v, const error_category& __cat) : _M_value(__v), _M_cat(&__cat) { } template error_condition(_ErrorConditionEnum __e, typename enable_if::value>::type* = 0) { *this = make_error_condition(__e); } void assign(int __v, const error_category& __cat) { _M_value = __v; _M_cat = &__cat; } // DR 804. template typename enable_if::value, error_condition&>::type operator=(_ErrorConditionEnum __e) { return *this = make_error_condition(__e); } void clear() { assign(0, generic_category()); } // 19.4.3.4 observers int value() const { return _M_value; } const error_category& category() const { return *_M_cat; } string message() const { return category().message(value()); } explicit operator bool() const { return _M_value != 0 ? true : false; } // DR 804. private: int _M_value; const error_category* _M_cat; }; // 19.4.3.6 non-member functions inline error_condition make_error_condition(errc __e) { return error_condition(static_cast(__e), generic_category()); } inline bool operator<(const error_condition& __lhs, const error_condition& __rhs) { return (__lhs.category() < __rhs.category() || (__lhs.category() == __rhs.category() && __lhs.value() < __rhs.value())); } // 19.4.4 Comparison operators inline bool operator==(const error_code& __lhs, const error_code& __rhs) { return (__lhs.category() == __rhs.category() && __lhs.value() == __rhs.value()); } inline bool operator==(const error_code& __lhs, const error_condition& __rhs) { return (__lhs.category().equivalent(__lhs.value(), __rhs) || __rhs.category().equivalent(__lhs, __rhs.value())); } inline bool operator==(const error_condition& __lhs, const error_code& __rhs) { return (__rhs.category().equivalent(__rhs.value(), __lhs) || __lhs.category().equivalent(__rhs, __lhs.value())); } inline bool operator==(const error_condition& __lhs, const error_condition& __rhs) { return (__lhs.category() == __rhs.category() && __lhs.value() == __rhs.value()); } inline bool operator!=(const error_code& __lhs, const error_code& __rhs) { return !(__lhs == __rhs); } inline bool operator!=(const error_code& __lhs, const error_condition& __rhs) { return !(__lhs == __rhs); } inline bool operator!=(const error_condition& __lhs, const error_code& __rhs) { return !(__lhs == __rhs); } inline bool operator!=(const error_condition& __lhs, const error_condition& __rhs) { return !(__lhs == __rhs); } /** * @brief Thrown to indicate error code of underlying system. * * @ingroup exceptions */ class system_error : public std::runtime_error { private: error_code _M_code; public: system_error(error_code __ec = error_code()) : runtime_error(__ec.message()), _M_code(__ec) { } system_error(error_code __ec, const string& __what) : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } /* * TODO: Add const char* ctors to all exceptions. * * system_error(error_code __ec, const char* __what) * : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } * * system_error(int __v, const error_category& __ecat, const char* __what) * : runtime_error(__what + (": " + __ec.message())), * _M_code(error_code(__v, __ecat)) { } */ system_error(int __v, const error_category& __ecat) : runtime_error(error_code(__v, __ecat).message()), _M_code(__v, __ecat) { } system_error(int __v, const error_category& __ecat, const string& __what) : runtime_error(__what + ": " + error_code(__v, __ecat).message()), _M_code(__v, __ecat) { } virtual ~system_error() throw(); const error_code& code() const throw() { return _M_code; } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #ifndef _GLIBCXX_COMPATIBILITY_CXX0X #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // DR 1182. /// std::hash specialization for error_code. template<> struct hash : public __hash_base { size_t operator()(const error_code& __e) const { const size_t __tmp = std::_Hash_impl::hash(__e._M_value); return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // _GLIBCXX_COMPATIBILITY_CXX0X #endif // __GXX_EXPERIMENTAL_CXX0X__ #endif // _GLIBCXX_SYSTEM_ERROR