// <system_error> -*- C++ -*-
-// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
+// 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 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 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 include/system_error
* This is a Standard C++ Library header.
*/
#pragma GCC system_header
#ifndef __GXX_EXPERIMENTAL_CXX0X__
-# include <c++0x_warning.h>
-#endif
+# include <bits/c++0x_warning.h>
+#else
#include <bits/c++config.h>
#include <bits/error_constants.h>
#include <iosfwd>
#include <stdexcept>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
class error_code;
class error_condition;
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>
- : 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();
+
+ 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();
+ // DR 890.
+ _GLIBCXX_CONST const error_category& system_category() throw();
+ _GLIBCXX_CONST const error_category& generic_category() throw();
+
+ error_code make_error_code(errc);
- static const error_category& system_category = get_system_category();
- static const error_category& native_category = get_posix_category();
+ template<typename _Tp>
+ struct hash;
/// 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)
- { }
+ { *this = make_error_code(__e); }
void
assign(int __v, const error_category& __cat)
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; }
+ { return *this = make_error_code(__e); }
int
value() const { return _M_value; }
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; }
+ explicit operator bool() const
+ { return _M_value != 0 ? true : false; }
+ // DR 804.
private:
+ friend class hash<error_code>;
+
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 make_error_condition(errc);
/// 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)
+ { *this = make_error_condition(__e); }
- 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)
+ { return *this = make_error_condition(__e); }
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
{ 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; }
+ explicit operator bool() const
+ { return _M_value != 0 ? true : 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:
public:
system_error(error_code __ec = error_code())
- : runtime_error(""), _M_code(__ec) { }
+ : runtime_error(__ec.message()), _M_code(__ec) { }
system_error(error_code __ec, const string& __what)
- : runtime_error(__what), _M_code(__ec) { }
+ : 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(""), _M_code(error_code(__v, __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), _M_code(error_code(__v, __ecat)) { }
+ : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+ _M_code(__v, __ecat) { }
virtual ~system_error() throw();
code() const throw() { return _M_code; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
+
+#include <bits/functional_hash.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // DR 1182.
+ /// std::hash specialization for error_code.
+ template<>
+ struct hash<error_code>
+ : public __hash_base<size_t, error_code>
+ {
+ 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
+#endif // __GXX_EXPERIMENTAL_CXX0X__
+#endif // _GLIBCXX_SYSTEM_ERROR
OSDN Git Service
