// <system_error> -*- C++ -*-
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// 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 2, or (at your option)
+// 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,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-// Boston, MA 02110-1301, USA.
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
-
-/** @file include/system_error
+// 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 __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
-#endif
+#else
#include <bits/c++config.h>
#include <bits/error_constants.h>
_GLIBCXX_BEGIN_NAMESPACE(std)
- class system_error;
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 { };
- extern const error_category& system_category;
+ template<>
+ struct is_error_code_enum<errc>
+ : public true_type { };
- struct error_category
+ /// 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
{
- 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
bool
operator!=(const error_category& __other) const
{ return this != &__other; }
-
- virtual posix_error::posix_errno
- posix(int __v) const = 0;
-
- virtual const string&
- name() const = 0;
-
- private:
- error_category(const error_category&);
-
- error_category&
- operator=(const error_category&);
};
+ // DR 890.
+ const error_category& system_category();
+ const error_category& generic_category();
+
+ /// error_code
+ // Implementation-specific error identification
struct error_code
{
- error_code() throw()
- : _M_value(0), _M_cat(&system_category) { }
+ error_code()
+ : _M_value(0), _M_cat(&system_category()) { }
- error_code(int __v, const error_category& __cat) throw()
+ error_code(int __v, const error_category& __cat)
: _M_value(__v), _M_cat(&__cat) { }
- error_code(posix_error::posix_errno __v)
- : _M_value(__v), _M_cat(&system_category) { }
+ template<typename _ErrorCodeEnum>
+ error_code(_ErrorCodeEnum __e,
+ typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type* = 0)
+ : _M_value(static_cast<int>(__e)), _M_cat(&generic_category())
+ { }
void
- assign(int __v, const error_category& __cat) throw()
+ assign(int __v, const error_category& __cat)
{
_M_value = __v;
_M_cat = &__cat;
}
void
- clear() throw()
- {
- _M_value = 0;
- _M_cat = &system_category;
- }
+ 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)
+ {
+ assign(static_cast<int>(__e), generic_category());
+ return *this;
+ }
int
- value() const throw() { return _M_value; }
+ value() const { return _M_value; }
const error_category&
category() const { return *_M_cat; }
- posix_error::posix_errno
- posix() const throw() { return this->category().posix(_M_value); }
+ error_condition
+ default_error_condition() const;
+
+ string
+ message() const
+ { return category().message(value()); }
// Safe bool idiom.
// explicit operator bool() const throw()
static void __not_bool_type() { }
- operator __bool_type() const throw()
+ operator __bool_type() const
{ return _M_value != 0 ? &__not_bool_type : false; }
- bool operator==(const error_code& __other) const
- { return value() == __other.value() && category() == __other.category(); }
+ // 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
+ // 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)
+ : _M_value(static_cast<int>(__e)), _M_cat(&generic_category()) { }
+
+ 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)
+ {
+ assign(static_cast<int>(__e), generic_category());
+ return *this;
+ }
+
+ 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() { }
- bool operator!=(const error_code& __other) const
- { return !(this == &__other); }
+ operator __bool_type() const
+ { return _M_value != 0 ? &__not_bool_type : false; }
+ // DR 804.
private:
- int _M_value;
+ 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(const string& __what, error_code __ec = error_code())
- : runtime_error(__what), _M_code(__ec) { }
+ system_error(error_code __ec = error_code())
+ : runtime_error(""), _M_code(__ec) { }
- system_error(const string& __what, int __v, const error_category& __ecat)
+ 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();
_GLIBCXX_END_NAMESPACE
-#endif
+#endif // __GXX_EXPERIMENTAL_CXX0X__
+
+#endif // _GLIBCXX_SYSTEM_ERROR
OSDN Git Service
