system_error revision 341825 
1// -*- C++ -*-
2//===---------------------------- system_error ----------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_SYSTEM_ERROR
12#define _LIBCPP_SYSTEM_ERROR
13
14/*
15    system_error synopsis
16
17namespace std
18{
19
20class error_category
21{
22public:
23    virtual ~error_category() noexcept;
24
25    constexpr error_category();
26    error_category(const error_category&) = delete;
27    error_category& operator=(const error_category&) = delete;
28
29    virtual const char* name() const noexcept = 0;
30    virtual error_condition default_error_condition(int ev) const noexcept;
31    virtual bool equivalent(int code, const error_condition& condition) const noexcept;
32    virtual bool equivalent(const error_code& code, int condition) const noexcept;
33    virtual string message(int ev) const = 0;
34
35    bool operator==(const error_category& rhs) const noexcept;
36    bool operator!=(const error_category& rhs) const noexcept;
37    bool operator<(const error_category& rhs) const noexcept;
38};
39
40const error_category& generic_category() noexcept;
41const error_category& system_category() noexcept;
42
43template <class T> struct is_error_code_enum
44    : public false_type {};
45
46template <class T> struct is_error_condition_enum
47    : public false_type {};
48
49template <class _Tp>
50inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
51
52template <class _Tp>
53inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
54
55class error_code
56{
57public:
58    // constructors:
59    error_code() noexcept;
60    error_code(int val, const error_category& cat) noexcept;
61    template <class ErrorCodeEnum>
62        error_code(ErrorCodeEnum e) noexcept;
63
64    // modifiers:
65    void assign(int val, const error_category& cat) noexcept;
66    template <class ErrorCodeEnum>
67        error_code& operator=(ErrorCodeEnum e) noexcept;
68    void clear() noexcept;
69
70    // observers:
71    int value() const noexcept;
72    const error_category& category() const noexcept;
73    error_condition default_error_condition() const noexcept;
74    string message() const;
75    explicit operator bool() const noexcept;
76};
77
78// non-member functions:
79bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
80template <class charT, class traits>
81    basic_ostream<charT,traits>&
82    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
83
84class error_condition
85{
86public:
87    // constructors:
88    error_condition() noexcept;
89    error_condition(int val, const error_category& cat) noexcept;
90    template <class ErrorConditionEnum>
91        error_condition(ErrorConditionEnum e) noexcept;
92
93    // modifiers:
94    void assign(int val, const error_category& cat) noexcept;
95    template <class ErrorConditionEnum>
96        error_condition& operator=(ErrorConditionEnum e) noexcept;
97    void clear() noexcept;
98
99    // observers:
100    int value() const noexcept;
101    const error_category& category() const noexcept;
102    string message() const noexcept;
103    explicit operator bool() const noexcept;
104};
105
106bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
107
108class system_error
109    : public runtime_error
110{
111public:
112    system_error(error_code ec, const string& what_arg);
113    system_error(error_code ec, const char* what_arg);
114    system_error(error_code ec);
115    system_error(int ev, const error_category& ecat, const string& what_arg);
116    system_error(int ev, const error_category& ecat, const char* what_arg);
117    system_error(int ev, const error_category& ecat);
118
119    const error_code& code() const noexcept;
120    const char* what() const noexcept;
121};
122
123template <> struct is_error_condition_enum<errc>
124    : true_type { }
125
126error_code make_error_code(errc e) noexcept;
127error_condition make_error_condition(errc e) noexcept;
128
129// Comparison operators:
130bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
131bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
132bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
133bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
134bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
135bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
136bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
137bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
138
139template <> struct hash<std::error_code>;
140template <> struct hash<std::error_condition>;
141
142}  // std
143
144*/
145
146#include <__errc>
147#include <type_traits>
148#include <stdexcept>
149#include <__functional_base>
150#include <string>
151
152#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
153#pragma GCC system_header
154#endif
155
156_LIBCPP_BEGIN_NAMESPACE_STD
157
158// is_error_code_enum
159
160template <class _Tp>
161struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
162    : public false_type {};
163
164#if _LIBCPP_STD_VER > 14
165template <class _Tp>
166_LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
167#endif
168
169// is_error_condition_enum
170
171template <class _Tp>
172struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
173    : public false_type {};
174
175#if _LIBCPP_STD_VER > 14
176template <class _Tp>
177_LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
178#endif
179
180template <>
181struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
182    : true_type { };
183
184#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
185template <>
186struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
187    : true_type { };
188#endif
189
190class _LIBCPP_TYPE_VIS error_condition;
191class _LIBCPP_TYPE_VIS error_code;
192
193// class error_category
194
195class _LIBCPP_HIDDEN __do_message;
196
197class _LIBCPP_TYPE_VIS error_category
198{
199public:
200    virtual ~error_category() _NOEXCEPT;
201
202#if defined(_LIBCPP_BUILDING_LIBRARY) && \
203    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
204    error_category() _NOEXCEPT;
205#else
206    _LIBCPP_INLINE_VISIBILITY
207    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
208#endif
209private:
210    error_category(const error_category&);// = delete;
211    error_category& operator=(const error_category&);// = delete;
212
213public:
214    virtual const char* name() const _NOEXCEPT = 0;
215    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
216    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
217    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
218    virtual string message(int __ev) const = 0;
219
220    _LIBCPP_INLINE_VISIBILITY
221    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
222
223    _LIBCPP_INLINE_VISIBILITY
224    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
225
226    _LIBCPP_INLINE_VISIBILITY
227    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
228
229    friend class _LIBCPP_HIDDEN __do_message;
230};
231
232class _LIBCPP_HIDDEN __do_message
233    : public error_category
234{
235public:
236    virtual string message(int ev) const;
237};
238
239_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
240_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
241
242class _LIBCPP_TYPE_VIS error_condition
243{
244    int __val_;
245    const error_category* __cat_;
246public:
247    _LIBCPP_INLINE_VISIBILITY
248    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
249
250    _LIBCPP_INLINE_VISIBILITY
251    error_condition(int __val, const error_category& __cat) _NOEXCEPT
252        : __val_(__val), __cat_(&__cat) {}
253
254    template <class _Ep>
255        _LIBCPP_INLINE_VISIBILITY
256        error_condition(_Ep __e,
257              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
258                                                                     ) _NOEXCEPT
259            {*this = make_error_condition(__e);}
260
261    _LIBCPP_INLINE_VISIBILITY
262    void assign(int __val, const error_category& __cat) _NOEXCEPT
263    {
264        __val_ = __val;
265        __cat_ = &__cat;
266    }
267
268    template <class _Ep>
269        _LIBCPP_INLINE_VISIBILITY
270        typename enable_if
271        <
272            is_error_condition_enum<_Ep>::value,
273            error_condition&
274        >::type
275        operator=(_Ep __e) _NOEXCEPT
276            {*this = make_error_condition(__e); return *this;}
277
278    _LIBCPP_INLINE_VISIBILITY
279    void clear() _NOEXCEPT
280    {
281        __val_ = 0;
282        __cat_ = &generic_category();
283    }
284
285    _LIBCPP_INLINE_VISIBILITY
286    int value() const _NOEXCEPT {return __val_;}
287
288    _LIBCPP_INLINE_VISIBILITY
289    const error_category& category() const _NOEXCEPT {return *__cat_;}
290    string message() const;
291
292    _LIBCPP_INLINE_VISIBILITY
293        _LIBCPP_EXPLICIT
294        operator bool() const _NOEXCEPT {return __val_ != 0;}
295};
296
297inline _LIBCPP_INLINE_VISIBILITY
298error_condition
299make_error_condition(errc __e) _NOEXCEPT
300{
301    return error_condition(static_cast<int>(__e), generic_category());
302}
303
304inline _LIBCPP_INLINE_VISIBILITY
305bool
306operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
307{
308    return __x.category() < __y.category()
309        || (__x.category() == __y.category() && __x.value() < __y.value());
310}
311
312// error_code
313
314class _LIBCPP_TYPE_VIS error_code
315{
316    int __val_;
317    const error_category* __cat_;
318public:
319    _LIBCPP_INLINE_VISIBILITY
320    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
321
322    _LIBCPP_INLINE_VISIBILITY
323    error_code(int __val, const error_category& __cat) _NOEXCEPT
324        : __val_(__val), __cat_(&__cat) {}
325
326    template <class _Ep>
327        _LIBCPP_INLINE_VISIBILITY
328        error_code(_Ep __e,
329                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
330                                                                     ) _NOEXCEPT
331            {*this = make_error_code(__e);}
332
333    _LIBCPP_INLINE_VISIBILITY
334    void assign(int __val, const error_category& __cat) _NOEXCEPT
335    {
336        __val_ = __val;
337        __cat_ = &__cat;
338    }
339
340    template <class _Ep>
341        _LIBCPP_INLINE_VISIBILITY
342        typename enable_if
343        <
344            is_error_code_enum<_Ep>::value,
345            error_code&
346        >::type
347        operator=(_Ep __e) _NOEXCEPT
348            {*this = make_error_code(__e); return *this;}
349
350    _LIBCPP_INLINE_VISIBILITY
351    void clear() _NOEXCEPT
352    {
353        __val_ = 0;
354        __cat_ = &system_category();
355    }
356
357    _LIBCPP_INLINE_VISIBILITY
358    int value() const _NOEXCEPT {return __val_;}
359
360    _LIBCPP_INLINE_VISIBILITY
361    const error_category& category() const _NOEXCEPT {return *__cat_;}
362
363    _LIBCPP_INLINE_VISIBILITY
364    error_condition default_error_condition() const _NOEXCEPT
365        {return __cat_->default_error_condition(__val_);}
366
367    string message() const;
368
369    _LIBCPP_INLINE_VISIBILITY
370        _LIBCPP_EXPLICIT
371        operator bool() const _NOEXCEPT {return __val_ != 0;}
372};
373
374inline _LIBCPP_INLINE_VISIBILITY
375error_code
376make_error_code(errc __e) _NOEXCEPT
377{
378    return error_code(static_cast<int>(__e), generic_category());
379}
380
381inline _LIBCPP_INLINE_VISIBILITY
382bool
383operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
384{
385    return __x.category() < __y.category()
386        || (__x.category() == __y.category() && __x.value() < __y.value());
387}
388
389inline _LIBCPP_INLINE_VISIBILITY
390bool
391operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
392{
393    return __x.category() == __y.category() && __x.value() == __y.value();
394}
395
396inline _LIBCPP_INLINE_VISIBILITY
397bool
398operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
399{
400    return __x.category().equivalent(__x.value(), __y)
401        || __y.category().equivalent(__x, __y.value());
402}
403
404inline _LIBCPP_INLINE_VISIBILITY
405bool
406operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
407{
408    return __y == __x;
409}
410
411inline _LIBCPP_INLINE_VISIBILITY
412bool
413operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
414{
415    return __x.category() == __y.category() && __x.value() == __y.value();
416}
417
418inline _LIBCPP_INLINE_VISIBILITY
419bool
420operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
421{return !(__x == __y);}
422
423inline _LIBCPP_INLINE_VISIBILITY
424bool
425operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
426{return !(__x == __y);}
427
428inline _LIBCPP_INLINE_VISIBILITY
429bool
430operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
431{return !(__x == __y);}
432
433inline _LIBCPP_INLINE_VISIBILITY
434bool
435operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
436{return !(__x == __y);}
437
438template <>
439struct _LIBCPP_TEMPLATE_VIS hash<error_code>
440    : public unary_function<error_code, size_t>
441{
442    _LIBCPP_INLINE_VISIBILITY
443    size_t operator()(const error_code& __ec) const _NOEXCEPT
444    {
445        return static_cast<size_t>(__ec.value());
446    }
447};
448
449template <>
450struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
451    : public unary_function<error_condition, size_t>
452{
453    _LIBCPP_INLINE_VISIBILITY
454    size_t operator()(const error_condition& __ec) const _NOEXCEPT
455    {
456        return static_cast<size_t>(__ec.value());
457    }
458};
459
460// system_error
461
462class _LIBCPP_TYPE_VIS system_error
463    : public runtime_error
464{
465    error_code __ec_;
466public:
467    system_error(error_code __ec, const string& __what_arg);
468    system_error(error_code __ec, const char* __what_arg);
469    system_error(error_code __ec);
470    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
471    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
472    system_error(int __ev, const error_category& __ecat);
473    ~system_error() _NOEXCEPT;
474
475    _LIBCPP_INLINE_VISIBILITY
476    const error_code& code() const _NOEXCEPT {return __ec_;}
477
478private:
479    static string __init(const error_code&, string);
480};
481
482_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
483void __throw_system_error(int ev, const char* what_arg);
484
485_LIBCPP_END_NAMESPACE_STD
486
487#endif  // _LIBCPP_SYSTEM_ERROR
488