1 // <system_error> -*- C++ -*-
3 // Copyright (C) 2007-2017 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 /** @file include/system_error
26 * This is a Standard C++ Library header.
29 #ifndef _GLIBCXX_SYSTEM_ERROR
30 #define _GLIBCXX_SYSTEM_ERROR 1
32 #pragma GCC system_header
34 #if __cplusplus < 201103L
35 # include <bits/c++0x_warning.h>
38 #include <bits/c++config.h>
39 #include <bits/error_constants.h>
43 namespace std _GLIBCXX_VISIBILITY(default)
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 class error_condition;
51 /// is_error_code_enum
52 template<typename _Tp>
53 struct is_error_code_enum : public false_type { };
55 /// is_error_condition_enum
56 template<typename _Tp>
57 struct is_error_condition_enum : public false_type { };
60 struct is_error_condition_enum<errc>
61 : public true_type { };
63 #if __cplusplus > 201402L
64 template <typename _Tp>
65 inline constexpr bool is_error_code_enum_v =
66 is_error_code_enum<_Tp>::value;
67 template <typename _Tp>
68 inline constexpr bool is_error_condition_enum_v =
69 is_error_condition_enum<_Tp>::value;
71 inline namespace _V2 {
77 constexpr error_category() noexcept = default;
79 virtual ~error_category();
81 error_category(const error_category&) = delete;
82 error_category& operator=(const error_category&) = delete;
85 name() const noexcept = 0;
87 // We need two different virtual functions here, one returning a
88 // COW string and one returning an SSO string. Their positions in the
89 // vtable must be consistent for dynamic dispatch to work, but which one
90 // the name "message()" finds depends on which ABI the caller is using.
91 #if _GLIBCXX_USE_CXX11_ABI
93 _GLIBCXX_DEFAULT_ABI_TAG
95 _M_message(int) const;
98 _GLIBCXX_DEFAULT_ABI_TAG
100 message(int) const = 0;
103 message(int) const = 0;
107 _M_message(int) const;
111 virtual error_condition
112 default_error_condition(int __i) const noexcept;
115 equivalent(int __i, const error_condition& __cond) const noexcept;
118 equivalent(const error_code& __code, int __i) const noexcept;
121 operator<(const error_category& __other) const noexcept
122 { return less<const error_category*>()(this, &__other); }
125 operator==(const error_category& __other) const noexcept
126 { return this == &__other; }
129 operator!=(const error_category& __other) const noexcept
130 { return this != &__other; }
134 _GLIBCXX_CONST const error_category& system_category() noexcept;
135 _GLIBCXX_CONST const error_category& generic_category() noexcept;
137 } // end inline namespace
139 error_code make_error_code(errc) noexcept;
141 template<typename _Tp>
145 // Implementation-specific error identification
148 error_code() noexcept
149 : _M_value(0), _M_cat(&system_category()) { }
151 error_code(int __v, const error_category& __cat) noexcept
152 : _M_value(__v), _M_cat(&__cat) { }
154 template<typename _ErrorCodeEnum, typename = typename
155 enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
156 error_code(_ErrorCodeEnum __e) noexcept
157 { *this = make_error_code(__e); }
160 assign(int __v, const error_category& __cat) noexcept
168 { assign(0, system_category()); }
171 template<typename _ErrorCodeEnum>
172 typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
174 operator=(_ErrorCodeEnum __e) noexcept
175 { return *this = make_error_code(__e); }
178 value() const noexcept { return _M_value; }
180 const error_category&
181 category() const noexcept { return *_M_cat; }
184 default_error_condition() const noexcept;
186 _GLIBCXX_DEFAULT_ABI_TAG
189 { return category().message(value()); }
191 explicit operator bool() const noexcept
192 { return _M_value != 0; }
196 friend class hash<error_code>;
199 const error_category* _M_cat;
202 // 19.4.2.6 non-member functions
204 make_error_code(errc __e) noexcept
205 { return error_code(static_cast<int>(__e), generic_category()); }
208 operator<(const error_code& __lhs, const error_code& __rhs) noexcept
210 return (__lhs.category() < __rhs.category()
211 || (__lhs.category() == __rhs.category()
212 && __lhs.value() < __rhs.value()));
215 template<typename _CharT, typename _Traits>
216 basic_ostream<_CharT, _Traits>&
217 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
218 { return (__os << __e.category().name() << ':' << __e.value()); }
220 error_condition make_error_condition(errc) noexcept;
223 // Portable error identification
224 struct error_condition
226 error_condition() noexcept
227 : _M_value(0), _M_cat(&generic_category()) { }
229 error_condition(int __v, const error_category& __cat) noexcept
230 : _M_value(__v), _M_cat(&__cat) { }
232 template<typename _ErrorConditionEnum, typename = typename
233 enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
234 error_condition(_ErrorConditionEnum __e) noexcept
235 { *this = make_error_condition(__e); }
238 assign(int __v, const error_category& __cat) noexcept
245 template<typename _ErrorConditionEnum>
246 typename enable_if<is_error_condition_enum
247 <_ErrorConditionEnum>::value, error_condition&>::type
248 operator=(_ErrorConditionEnum __e) noexcept
249 { return *this = make_error_condition(__e); }
253 { assign(0, generic_category()); }
255 // 19.4.3.4 observers
257 value() const noexcept { return _M_value; }
259 const error_category&
260 category() const noexcept { return *_M_cat; }
262 _GLIBCXX_DEFAULT_ABI_TAG
265 { return category().message(value()); }
267 explicit operator bool() const noexcept
268 { return _M_value != 0; }
273 const error_category* _M_cat;
276 // 19.4.3.6 non-member functions
277 inline error_condition
278 make_error_condition(errc __e) noexcept
279 { return error_condition(static_cast<int>(__e), generic_category()); }
282 operator<(const error_condition& __lhs,
283 const error_condition& __rhs) noexcept
285 return (__lhs.category() < __rhs.category()
286 || (__lhs.category() == __rhs.category()
287 && __lhs.value() < __rhs.value()));
290 // 19.4.4 Comparison operators
292 operator==(const error_code& __lhs, const error_code& __rhs) noexcept
293 { return (__lhs.category() == __rhs.category()
294 && __lhs.value() == __rhs.value()); }
297 operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
299 return (__lhs.category().equivalent(__lhs.value(), __rhs)
300 || __rhs.category().equivalent(__lhs, __rhs.value()));
304 operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
306 return (__rhs.category().equivalent(__rhs.value(), __lhs)
307 || __lhs.category().equivalent(__rhs, __lhs.value()));
311 operator==(const error_condition& __lhs,
312 const error_condition& __rhs) noexcept
314 return (__lhs.category() == __rhs.category()
315 && __lhs.value() == __rhs.value());
319 operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
320 { return !(__lhs == __rhs); }
323 operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
324 { return !(__lhs == __rhs); }
327 operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
328 { return !(__lhs == __rhs); }
331 operator!=(const error_condition& __lhs,
332 const error_condition& __rhs) noexcept
333 { return !(__lhs == __rhs); }
337 * @brief Thrown to indicate error code of underlying system.
339 * @ingroup exceptions
341 class system_error : public std::runtime_error
347 system_error(error_code __ec = error_code())
348 : runtime_error(__ec.message()), _M_code(__ec) { }
350 system_error(error_code __ec, const string& __what)
351 : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
353 system_error(error_code __ec, const char* __what)
354 : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
356 system_error(int __v, const error_category& __ecat, const char* __what)
357 : system_error(error_code(__v, __ecat), __what) { }
359 system_error(int __v, const error_category& __ecat)
360 : runtime_error(error_code(__v, __ecat).message()),
361 _M_code(__v, __ecat) { }
363 system_error(int __v, const error_category& __ecat, const string& __what)
364 : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
365 _M_code(__v, __ecat) { }
367 virtual ~system_error() noexcept;
370 code() const noexcept { return _M_code; }
373 _GLIBCXX_END_NAMESPACE_VERSION
376 #include <bits/functional_hash.h>
378 namespace std _GLIBCXX_VISIBILITY(default)
380 _GLIBCXX_BEGIN_NAMESPACE_VERSION
382 #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
384 /// std::hash specialization for error_code.
386 struct hash<error_code>
387 : public __hash_base<size_t, error_code>
390 operator()(const error_code& __e) const noexcept
392 const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
393 return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
396 #endif // _GLIBCXX_COMPATIBILITY_CXX0X
398 #if __cplusplus > 201402L
400 /// std::hash specialization for error_condition.
402 struct hash<error_condition>
403 : public __hash_base<size_t, error_condition>
406 operator()(const error_condition& __e) const noexcept
408 const size_t __tmp = std::_Hash_impl::hash(__e.value());
409 return std::_Hash_impl::__hash_combine(__e.category(), __tmp);
414 _GLIBCXX_END_NAMESPACE_VERSION
419 #endif // _GLIBCXX_SYSTEM_ERROR