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