diff options
Diffstat (limited to 'gcc-4.4.3/libstdc++-v3/include/std/system_error')
| -rw-r--r-- | gcc-4.4.3/libstdc++-v3/include/std/system_error | 353 |
1 files changed, 353 insertions, 0 deletions
diff --git a/gcc-4.4.3/libstdc++-v3/include/std/system_error b/gcc-4.4.3/libstdc++-v3/include/std/system_error new file mode 100644 index 000000000..02dd2df1e --- /dev/null +++ b/gcc-4.4.3/libstdc++-v3/include/std/system_error @@ -0,0 +1,353 @@ +// <system_error> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009 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 +// <http://www.gnu.org/licenses/>. + +/** @file 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 <c++0x_warning.h> +#else + +#include <bits/c++config.h> +#include <bits/error_constants.h> +#include <iosfwd> +#include <stdexcept> + +_GLIBCXX_BEGIN_NAMESPACE(std) + + class error_code; + class error_condition; + class error_category; + class system_error; + + /// is_error_code_enum + template<typename _Tp> + struct is_error_code_enum : public false_type { }; + + /// is_error_condition_enum + template<typename _Tp> + struct is_error_condition_enum : public false_type { }; + + template<> + struct is_error_condition_enum<errc> + : public true_type { }; + + + /// error_category + class error_category + { + protected: + error_category() = default; + + 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<const error_category*>()(this, &__other); } + + bool + operator==(const error_category& __other) const + { return this == &__other; } + + bool + operator!=(const error_category& __other) const + { return this != &__other; } + }; + + // DR 890. + const error_category& system_category(); + const error_category& generic_category(); + + error_code make_error_code(errc); + + /// 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<typename _ErrorCodeEnum> + error_code(_ErrorCodeEnum __e, + typename enable_if<is_error_code_enum<_ErrorCodeEnum>::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 _ErrorCodeEnum> + typename enable_if<is_error_code_enum<_ErrorCodeEnum>::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()); } + + // Safe bool idiom. + // explicit operator bool() const throw() + // { return _M_value != 0; } + typedef void (*__bool_type)(); + + static void __not_bool_type() { } + + operator __bool_type() const + { return _M_value != 0 ? &__not_bool_type : false; } + + // DR 804. + private: + 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<int>(__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<typename _CharT, typename _Traits> + 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<typename _ErrorConditionEnum> + error_condition(_ErrorConditionEnum __e, + typename enable_if<is_error_condition_enum + <_ErrorConditionEnum>::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 _ErrorConditionEnum> + typename enable_if<is_error_condition_enum + <_ErrorConditionEnum>::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()); } + + // Safe bool idiom. + // explicit operator bool() const throw() + // { return _M_value != 0; } + typedef void (*__bool_type)(); + + static void __not_bool_type() { } + + operator __bool_type() const + { return _M_value != 0 ? &__not_bool_type : 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<int>(__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(""), _M_code(__ec) { } + + system_error(error_code __ec, const string& __what) + : runtime_error(__what), _M_code(__ec) { } + + /* + * TODO: Add const char* ctors to all exceptions. + * + * system_error(error_code __ec, const char* __what) + * : runtime_error(__what), _M_code(__ec) { } + * + * system_error(int __v, const error_category& __ecat, const char* __what) + * : runtime_error(__what), _M_code(error_code(__v, __ecat)) { } + */ + + system_error(int __v, const error_category& __ecat) + : runtime_error(""), _M_code(error_code(__v, __ecat)) { } + + system_error(int __v, const error_category& __ecat, const string& __what) + : runtime_error(__what), _M_code(error_code(__v, __ecat)) { } + + virtual ~system_error() throw(); + + const error_code& + code() const throw() { return _M_code; } + }; + +_GLIBCXX_END_NAMESPACE + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_SYSTEM_ERROR + |