// <system_error> -*- C++ -*-
-// Copyright (C) 2007, 2008 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.
+// 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.
-// 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.
+// 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.
class system_error;
/// is_error_code_enum
- template<typename _T>
+ template<typename _Tp>
struct is_error_code_enum : public false_type { };
template<>
- struct is_error_code_enum<posix_error::posix_errno>
+ struct is_error_code_enum<errc>
: public true_type { };
/// is_error_condition_enum
- template<typename _T>
+ template<typename _Tp>
struct is_error_condition_enum : public false_type { };
template<>
- struct is_error_condition_enum<posix_error::posix_errno>
+ struct is_error_condition_enum<errc>
: public true_type { };
/// error_category
- struct 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;
bool
operator!=(const error_category& __other) const
{ return this != &__other; }
-
- private:
- error_category(const error_category&);
-
- error_category&
- operator=(const error_category&);
};
- const error_category& get_posix_category();
- const error_category& get_system_category();
-
- static const error_category& system_category = get_system_category();
- static const error_category& native_category = get_posix_category();
+ // DR 890.
+ const error_category& system_category();
+ const error_category& generic_category();
/// error_code
// Implementation-specific error identification
struct error_code
{
error_code()
- : _M_value(0), _M_cat(&system_category) { }
+ : _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)
- : _M_value(__e), _M_cat(&system_category)
+ : _M_value(static_cast<int>(__e)), _M_cat(&generic_category())
{ }
void
void
clear()
- {
- _M_value = 0;
- _M_cat = &system_category;
- }
+ { assign(0, system_category()); }
+ // DR 804.
template<typename _ErrorCodeEnum>
- typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type&
+ typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+ error_code&>::type
operator=(_ErrorCodeEnum __e)
- { _M_value = __e; }
+ {
+ assign(static_cast<int>(__e), generic_category());
+ return *this;
+ }
int
value() const { return _M_value; }
operator __bool_type() const
{ return _M_value != 0 ? &__not_bool_type : false; }
+ // DR 804.
private:
int _M_value;
const error_category* _M_cat;
};
- error_code
- make_error_code(posix_error::posix_errno);
+ // 19.4.2.6 non-member functions
+ inline error_code
+ make_error_code(errc __e)
+ { return error_code(static_cast<int>(__e), generic_category()); }
- // 19.4.2.5 non-member functions
- bool operator<(const error_code& lhs, const error_code& rhs);
+ 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& __code);
+ 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(system_category) { }
+ error_condition() : _M_value(0), _M_cat(&generic_category()) { }
error_condition(int __v, const error_category& __cat)
- : _M_value(__v), _M_cat(__cat) { }
+ : _M_value(__v), _M_cat(&__cat) { }
- template<typename _ErrorEnum>
- error_condition(typename enable_if<
- is_error_condition_enum<_ErrorEnum>::value,
- _ErrorEnum>::type __v)
- : _M_value(__v), _M_cat(system_category) { }
+ 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 val, const error_category& cat);
+ void
+ assign(int __v, const error_category& __cat)
+ {
+ _M_value = __v;
+ _M_cat = &__cat;
+ }
- template<typename _ErrorEnum>
- error_condition&
- operator=(typename enable_if<is_error_condition_enum<_ErrorEnum>::value,
- _ErrorEnum>::type __v)
- { _M_value = __v; }
+ // 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();
+ clear()
+ { assign(0, generic_category()); }
// 19.4.3.4 observers
int
value() const { return _M_value; }
- const error_category&
- category() const { return _M_cat; }
+ const error_category&
+ category() const { return *_M_cat; }
string
message() const
operator __bool_type() const
{ return _M_value != 0 ? &__not_bool_type : false; }
+ // DR 804.
private:
int _M_value;
- const error_category& _M_cat;
+ const error_category* _M_cat;
};
- error_condition
- make_error_condition(posix_error::posix_errno);
+ // 19.4.3.6 non-member functions
+ inline error_condition
+ make_error_condition(errc __e)
+ { return error_condition(static_cast<int>(__e), generic_category()); }
- // 19.4.3.5 non-member functions
inline bool
- operator<(const error_condition& lhs, const error_condition& rhs)
- {
- bool __t1 = lhs.category() < rhs.category();
- bool __t2 = lhs.category() == rhs.category() && lhs.value() < rhs.value();
- return __t1 || __t2;
+ 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_code& __rhs)
+ { return (__lhs.category() == __rhs.category()
+ && __lhs.value() == __rhs.value()); }
- inline bool
- operator==(const error_code& lhs, const error_condition& rhs)
+ inline bool
+ operator==(const error_code& __lhs, const error_condition& __rhs)
{
- bool __t1 = lhs.category().equivalent(lhs.value(), rhs);
- bool __t2 = rhs.category().equivalent(lhs, rhs.value());
- return __t1 || __t2;
+ return (__lhs.category().equivalent(__lhs.value(), __rhs)
+ || __rhs.category().equivalent(__lhs, __rhs.value()));
}
- inline bool
- operator==(const error_condition& lhs, const error_code& rhs)
+ inline bool
+ operator==(const error_condition& __lhs, const error_code& __rhs)
{
- bool __t1 = rhs.category().equivalent(rhs.value(), lhs);
- bool __t2 = lhs.category().equivalent(rhs, lhs.value());
- return __t1 || __t2;
+ 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_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_code& __rhs)
+ { return !(__lhs == __rhs); }
- inline bool
- operator!=(const error_code& lhs, const error_condition& 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_code& __rhs)
+ { return !(__lhs == __rhs); }
+
+ inline bool
+ operator!=(const error_condition& __lhs, const error_condition& __rhs)
+ { return !(__lhs == __rhs); }
- inline bool
- operator!=(const error_condition& lhs, const error_condition& rhs)
- { return !(lhs == rhs); }
- /// Thrown to indicate error code of underlying system.
+ /**
+ * @brief Thrown to indicate error code of underlying system.
+ *
+ * @ingroup exceptions
+ */
class system_error : public std::runtime_error
{
private:
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)) { }
OSDN Git Service
