1 // <system_error> -*- C++ -*-
3 // Copyright (C) 2007, 2008, 2009, 2010 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 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 #ifndef __GXX_EXPERIMENTAL_CXX0X__
35 # include <bits/c++0x_warning.h>
38 #include <bits/c++config.h>
39 #include <bits/error_constants.h>
43 _GLIBCXX_BEGIN_NAMESPACE(std)
46 class error_condition;
50 /// is_error_code_enum
51 template<typename _Tp>
52 struct is_error_code_enum : public false_type { };
54 /// is_error_condition_enum
55 template<typename _Tp>
56 struct is_error_condition_enum : public false_type { };
59 struct is_error_condition_enum<errc>
60 : public true_type { };
70 virtual ~error_category() { }
72 error_category(const error_category&) = delete;
73 error_category& operator=(const error_category&) = delete;
79 message(int) const = 0;
81 virtual error_condition
82 default_error_condition(int __i) const;
85 equivalent(int __i, const error_condition& __cond) const;
88 equivalent(const error_code& __code, int __i) const;
91 operator<(const error_category& __other) const
92 { return less<const error_category*>()(this, &__other); }
95 operator==(const error_category& __other) const
96 { return this == &__other; }
99 operator!=(const error_category& __other) const
100 { return this != &__other; }
103 inline error_category::error_category() = default;
106 _GLIBCXX_CONST const error_category& system_category() throw();
107 _GLIBCXX_CONST const error_category& generic_category() throw();
109 error_code make_error_code(errc);
112 // Implementation-specific error identification
116 : _M_value(0), _M_cat(&system_category()) { }
118 error_code(int __v, const error_category& __cat)
119 : _M_value(__v), _M_cat(&__cat) { }
121 template<typename _ErrorCodeEnum>
122 error_code(_ErrorCodeEnum __e,
123 typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type* = 0)
124 { *this = make_error_code(__e); }
127 assign(int __v, const error_category& __cat)
135 { assign(0, system_category()); }
138 template<typename _ErrorCodeEnum>
139 typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
141 operator=(_ErrorCodeEnum __e)
142 { return *this = make_error_code(__e); }
145 value() const { return _M_value; }
147 const error_category&
148 category() const { return *_M_cat; }
151 default_error_condition() const;
155 { return category().message(value()); }
157 explicit operator bool() const
158 { return _M_value != 0 ? true : false; }
163 const error_category* _M_cat;
166 // 19.4.2.6 non-member functions
168 make_error_code(errc __e)
169 { return error_code(static_cast<int>(__e), generic_category()); }
172 operator<(const error_code& __lhs, const error_code& __rhs)
174 return (__lhs.category() < __rhs.category()
175 || (__lhs.category() == __rhs.category()
176 && __lhs.value() < __rhs.value()));
179 template<typename _CharT, typename _Traits>
180 basic_ostream<_CharT, _Traits>&
181 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
182 { return (__os << __e.category().name() << ':' << __e.value()); }
184 error_condition make_error_condition(errc);
187 // Portable error identification
188 struct error_condition
191 : _M_value(0), _M_cat(&generic_category()) { }
193 error_condition(int __v, const error_category& __cat)
194 : _M_value(__v), _M_cat(&__cat) { }
196 template<typename _ErrorConditionEnum>
197 error_condition(_ErrorConditionEnum __e,
198 typename enable_if<is_error_condition_enum
199 <_ErrorConditionEnum>::value>::type* = 0)
200 { *this = make_error_condition(__e); }
203 assign(int __v, const error_category& __cat)
210 template<typename _ErrorConditionEnum>
211 typename enable_if<is_error_condition_enum
212 <_ErrorConditionEnum>::value, error_condition&>::type
213 operator=(_ErrorConditionEnum __e)
214 { return *this = make_error_condition(__e); }
218 { assign(0, generic_category()); }
220 // 19.4.3.4 observers
222 value() const { return _M_value; }
224 const error_category&
225 category() const { return *_M_cat; }
229 { return category().message(value()); }
231 explicit operator bool() const
232 { return _M_value != 0 ? true : false; }
237 const error_category* _M_cat;
240 // 19.4.3.6 non-member functions
241 inline error_condition
242 make_error_condition(errc __e)
243 { return error_condition(static_cast<int>(__e), generic_category()); }
246 operator<(const error_condition& __lhs, const error_condition& __rhs)
248 return (__lhs.category() < __rhs.category()
249 || (__lhs.category() == __rhs.category()
250 && __lhs.value() < __rhs.value()));
253 // 19.4.4 Comparison operators
255 operator==(const error_code& __lhs, const error_code& __rhs)
256 { return (__lhs.category() == __rhs.category()
257 && __lhs.value() == __rhs.value()); }
260 operator==(const error_code& __lhs, const error_condition& __rhs)
262 return (__lhs.category().equivalent(__lhs.value(), __rhs)
263 || __rhs.category().equivalent(__lhs, __rhs.value()));
267 operator==(const error_condition& __lhs, const error_code& __rhs)
269 return (__rhs.category().equivalent(__rhs.value(), __lhs)
270 || __lhs.category().equivalent(__rhs, __lhs.value()));
274 operator==(const error_condition& __lhs, const error_condition& __rhs)
276 return (__lhs.category() == __rhs.category()
277 && __lhs.value() == __rhs.value());
281 operator!=(const error_code& __lhs, const error_code& __rhs)
282 { return !(__lhs == __rhs); }
285 operator!=(const error_code& __lhs, const error_condition& __rhs)
286 { return !(__lhs == __rhs); }
289 operator!=(const error_condition& __lhs, const error_code& __rhs)
290 { return !(__lhs == __rhs); }
293 operator!=(const error_condition& __lhs, const error_condition& __rhs)
294 { return !(__lhs == __rhs); }
298 * @brief Thrown to indicate error code of underlying system.
300 * @ingroup exceptions
302 class system_error : public std::runtime_error
308 system_error(error_code __ec = error_code())
309 : runtime_error(""), _M_code(__ec) { }
311 system_error(error_code __ec, const string& __what)
312 : runtime_error(__what), _M_code(__ec) { }
315 * TODO: Add const char* ctors to all exceptions.
317 * system_error(error_code __ec, const char* __what)
318 * : runtime_error(__what), _M_code(__ec) { }
320 * system_error(int __v, const error_category& __ecat, const char* __what)
321 * : runtime_error(__what), _M_code(error_code(__v, __ecat)) { }
324 system_error(int __v, const error_category& __ecat)
325 : runtime_error(""), _M_code(error_code(__v, __ecat)) { }
327 system_error(int __v, const error_category& __ecat, const string& __what)
328 : runtime_error(__what), _M_code(error_code(__v, __ecat)) { }
330 virtual ~system_error() throw();
333 code() const throw() { return _M_code; }
336 _GLIBCXX_END_NAMESPACE
338 #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
340 #include <bits/functional_hash.h>
342 _GLIBCXX_BEGIN_NAMESPACE(std)
345 /// std::hash specialization for error_code.
347 struct hash<error_code>
348 : public std::unary_function<error_code, size_t>
351 operator()(const error_code& __e) const
353 const char* __p = reinterpret_cast<const char*>(&__e);
354 return _Fnv_hash<>::hash(__p, sizeof(__e));
358 _GLIBCXX_END_NAMESPACE
360 #endif // _GLIBCXX_COMPATIBILITY_CXX0X
362 #endif // __GXX_EXPERIMENTAL_CXX0X__
364 #endif // _GLIBCXX_SYSTEM_ERROR