// <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.
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
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& posix_category = get_posix_category();
- static const error_category& system_category = get_system_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(&posix_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>
error_code&>::type
operator=(_ErrorCodeEnum __e)
{
- _M_value = __e;
- _M_cat = &posix_category;
+ assign(static_cast<int>(__e), generic_category());
return *this;
}
const error_category* _M_cat;
};
- // 19.4.2.5 non-member functions
+ // 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)
{
// Portable error identification
struct error_condition
{
- error_condition() : _M_value(0), _M_cat(&posix_category) { }
+ error_condition() : _M_value(0), _M_cat(&generic_category()) { }
error_condition(int __v, const error_category& __cat)
: _M_value(__v), _M_cat(&__cat) { }
error_condition(_ErrorConditionEnum __e,
typename enable_if<is_error_condition_enum
<_ErrorConditionEnum>::value>::type* = 0)
- : _M_value(__e), _M_cat(&posix_category) { }
+ : _M_value(static_cast<int>(__e)), _M_cat(&generic_category()) { }
void
assign(int __v, const error_category& __cat)
<_ErrorConditionEnum>::value, error_condition&>::type
operator=(_ErrorConditionEnum __e)
{
- _M_value = __e;
- _M_cat = &posix_category;
+ assign(static_cast<int>(__e), generic_category());
return *this;
}
void
clear()
- {
- _M_value = 0;
- _M_cat = &posix_category;
- }
+ { assign(0, generic_category()); }
// 19.4.3.4 observers
int
const error_category* _M_cat;
};
- // 19.4.3.5 non-member functions
+ // 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)
{
&& __lhs.value() < __rhs.value()));
}
- namespace posix_error
- {
- inline error_code
- make_error_code(posix_errno __e)
- { return error_code(__e, posix_category); }
-
- inline error_condition
- make_error_condition(posix_errno __e)
- { return error_condition(__e, posix_category); }
- }
-
// 19.4.4 Comparison operators
inline bool
operator==(const error_code& __lhs, const error_code& __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
