CbC/CbC_gcc: libstdc++-v3/include/std/system

comparison libstdc++-v3/include/std/system_error @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children	494b0b89df80

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 // <system_error> -*- C++ -*-
-// Copyright (C) 2007-2018 Free Software Foundation, Inc.
+// Copyright (C) 2007-2020 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)
 #include <stdexcept>
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
+/** @addtogroup diagnostics
+*  @{
+*/
 class error_code;
 class error_condition;
 class system_error;
 inline constexpr bool is_error_condition_enum_v =
 is_error_condition_enum<_Tp>::value;
 #endif // C++17
 inline namespace _V2 {
-/// error_category
+/** Abstract base class for types defining a category of error codes.
+*
+* An error category defines a context that give meaning to the integer
+* stored in an `error_code` or `error_condition` object. For example,
+* the standard `errno` constants such a `EINVAL` and `ENOMEM` are
+* associated with the "generic" category and other OS-specific error
+* numbers are associated with the "system" category, but a user-defined
+* category might give different meanings to the same numerical values.
+*/
 class error_category
 {
 public:
 constexpr error_category() noexcept = default;
 operator!=(const error_category& __other) const noexcept
 { return this != &__other; }
 };
 // DR 890.
+/// Error category for `errno` error codes.
+_GLIBCXX_CONST const error_category& generic_category() noexcept;
+/// Error category for other error codes defined by the OS.
 _GLIBCXX_CONST const error_category& system_category() noexcept;
-_GLIBCXX_CONST const error_category& generic_category() noexcept;
 } // end inline namespace
 error_code make_error_code(errc) noexcept;
-template<typename _Tp>
+/** Class error_code
-struct hash;
+*
+* This class is a value type storing an integer error number and a
-/// error_code
+* category that gives meaning to the error number. Typically this is done
-// Implementation-specific error identification
+* close the the point where the error happens, to capture the original
+* error value.
+*
+* An `error_code` object can be used to store the original error value
+* emitted by some subsystem, with a category relevant to the subsystem.
+* For example, errors from POSIX library functions can be represented by
+* an `errno` value and the "generic" category, but errors from an HTTP
+* library might be represented by an HTTP response status code (e.g. 404)
+* and a custom category defined by the library.
+*/
 struct error_code
 {
 error_code() noexcept
 : _M_value(0), _M_cat(&system_category()) { }
 explicit operator bool() const noexcept
 { return _M_value != 0; }
 // DR 804.
 private:
-friend class hash<error_code>;
 int            		_M_value;
 const error_category* 	_M_cat;
 };
 // 19.4.2.6 non-member functions
+/// @relates error_code @{
 inline error_code
 make_error_code(errc __e) noexcept
 { return error_code(static_cast<int>(__e), generic_category()); }
 inline bool
 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) noexcept;
-/// error_condition
+/** Class error_condition
-// Portable error identification
+*
+* This class represents error conditions that may be visible at an API
+* boundary. Different `error_code` values that can occur within a library
+* or module might map to the same `error_condition`.
+*
+* An `error_condition` represents something that the program can test for,
+* and subsequently take appropriate action.
+*/
 struct error_condition
 {
 error_condition() noexcept
 : _M_value(0), _M_cat(&generic_category()) { }
 int 			_M_value;
 const error_category* 	_M_cat;
 };
 // 19.4.3.6 non-member functions
+/// Create an `error_condition` representing a standard `errc` condition.
+/// @relates error_condition
 inline error_condition
 make_error_condition(errc __e) noexcept
 { return error_condition(static_cast<int>(__e), generic_category()); }
+/// Define an ordering for error_condition objects.
+/// @relates error_condition
 inline bool
 operator<(const error_condition& __lhs,
 	    const error_condition& __rhs) noexcept
 {
 return (__lhs.category() < __rhs.category()
 	    || (__lhs.category() == __rhs.category()
 		&& __lhs.value() < __rhs.value()));
 }
 // 19.4.4 Comparison operators
+/// @relates error_code
 inline bool
 operator==(const error_code& __lhs, const error_code& __rhs) noexcept
 { return (__lhs.category() == __rhs.category()
 	    && __lhs.value() == __rhs.value()); }
+/// @relates error_code
+/// @relates error_condition
 inline bool
 operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
 {
 return (__lhs.category().equivalent(__lhs.value(), __rhs)
 	    || __rhs.category().equivalent(__lhs, __rhs.value()));
 }
+/// @relates error_code
+/// @relates error_condition
 inline bool
 operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
 {
 return (__rhs.category().equivalent(__rhs.value(), __lhs)
 	    || __lhs.category().equivalent(__rhs, __lhs.value()));
 }
+/// @relates error_condition
 inline bool
 operator==(const error_condition& __lhs,
 	     const error_condition& __rhs) noexcept
 {
 return (__lhs.category() == __rhs.category()
 	    && __lhs.value() == __rhs.value());
 }
+/// @relates error_code
 inline bool
 operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
 { return !(__lhs == __rhs); }
+/// @relates error_code
+/// @relates error_condition
 inline bool
 operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
 { return !(__lhs == __rhs); }
+/// @relates error_code
+/// @relates error_condition
 inline bool
 operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
 { return !(__lhs == __rhs); }
+/// @relates error_condition
 inline bool
 operator!=(const error_condition& __lhs,
 	     const error_condition& __rhs) noexcept
 { return !(__lhs == __rhs); }
 /**
-*  @brief Thrown to indicate error code of underlying system.
+* @brief An exception type that includes an `error_code` value.
 *
-*  @ingroup exceptions
+* Typically used to report errors from the operating system and other
+* low-level APIs.
+*
+* @ingroup exceptions
 */
 class system_error : public std::runtime_error
 {
 private:
 error_code 	_M_code;
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
 // DR 1182.
 /// std::hash specialization for error_code.
+/// @relates error_code
 template<>
 struct hash<error_code>
 : public __hash_base<size_t, error_code>
 {
 size_t
 operator()(const error_code& __e) const noexcept
 {
-	const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
+	const size_t __tmp = std::_Hash_impl::hash(__e.value());
-	return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
+	return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
 }
 };
 #endif // _GLIBCXX_COMPATIBILITY_CXX0X
-#if __cplusplus > 201402L
+#if __cplusplus >= 201703L
 // DR 2686.
 /// std::hash specialization for error_condition.
+/// @relates error_condition
 template<>
 struct hash<error_condition>
 : public __hash_base<size_t, error_condition>
 {
 size_t
 operator()(const error_condition& __e) const noexcept
 {
 	const size_t __tmp = std::_Hash_impl::hash(__e.value());
-	return std::_Hash_impl::__hash_combine(__e.category(), __tmp);
+	return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
 }
 };
 #endif
 _GLIBCXX_END_NAMESPACE_VERSION

Mercurial > hg > CbC > CbC_gcc

comparison libstdc++-v3/include/std/system_error @ 145:1830386684a0