Coverage Report

Created: 2020-02-18 08:44

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/include/system_error
Line
Count
Source (jump to first uncovered line)
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
16
namespace std
17
{
18
19
class error_category
20
{
21
public:
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
39
const error_category& generic_category() noexcept;
40
const error_category& system_category() noexcept;
41
42
template <class T> struct is_error_code_enum
43
    : public false_type {};
44
45
template <class T> struct is_error_condition_enum
46
    : public false_type {};
47
48
template <class _Tp>
49
inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
50
51
template <class _Tp>
52
inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
53
54
class error_code
55
{
56
public:
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:
78
bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
79
template <class charT, class traits>
80
    basic_ostream<charT,traits>&
81
    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
82
83
class error_condition
84
{
85
public:
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
105
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
106
107
class system_error
108
    : public runtime_error
109
{
110
public:
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
122
template <> struct is_error_condition_enum<errc>
123
    : true_type { }
124
125
error_code make_error_code(errc e) noexcept;
126
error_condition make_error_condition(errc e) noexcept;
127
128
// Comparison operators:
129
bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
130
bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
131
bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
132
bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
133
bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
134
bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
135
bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
136
bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
137
138
template <> struct hash<std::error_code>;
139
template <> struct hash<std::error_condition>;
140
141
}  // std
142
143
*/
144
145
#include <__errc>
146
#include <type_traits>
147
#include <stdexcept>
148
#include <__functional_base>
149
#include <string>
150
151
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
152
#pragma GCC system_header
153
#endif
154
155
_LIBCPP_BEGIN_NAMESPACE_STD
156
157
// is_error_code_enum
158
159
template <class _Tp>
160
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
161
    : public false_type {};
162
163
#if _LIBCPP_STD_VER > 14
164
template <class _Tp>
165
_LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
166
#endif
167
168
// is_error_condition_enum
169
170
template <class _Tp>
171
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
172
    : public false_type {};
173
174
#if _LIBCPP_STD_VER > 14
175
template <class _Tp>
176
_LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
177
#endif
178
179
template <>
180
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
181
    : true_type { };
182
183
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
184
template <>
185
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
186
    : true_type { };
187
#endif
188
189
class _LIBCPP_TYPE_VIS error_condition;
190
class _LIBCPP_TYPE_VIS error_code;
191
192
// class error_category
193
194
class _LIBCPP_HIDDEN __do_message;
195
196
class _LIBCPP_TYPE_VIS error_category
197
{
198
public:
199
    virtual ~error_category() _NOEXCEPT;
200
201
#if defined(_LIBCPP_BUILDING_LIBRARY) && \
202
    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
203
    error_category() _NOEXCEPT;
204
#else
205
    _LIBCPP_INLINE_VISIBILITY
206
    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
207
#endif
208
private:
209
    error_category(const error_category&);// = delete;
210
    error_category& operator=(const error_category&);// = delete;
211
212
public:
213
    virtual const char* name() const _NOEXCEPT = 0;
214
    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
215
    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
216
    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
217
    virtual string message(int __ev) const = 0;
218
219
    _LIBCPP_INLINE_VISIBILITY
220
12.9M
    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
221
222
    _LIBCPP_INLINE_VISIBILITY
223
0
    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
224
225
    _LIBCPP_INLINE_VISIBILITY
226
0
    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
227
228
    friend class _LIBCPP_HIDDEN __do_message;
229
};
230
231
class _LIBCPP_HIDDEN __do_message
232
    : public error_category
233
{
234
public:
235
    virtual string message(int ev) const;
236
};
237
238
_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
239
_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
240
241
class _LIBCPP_TYPE_VIS error_condition
242
{
243
    int __val_;
244
    const error_category* __cat_;
245
public:
246
    _LIBCPP_INLINE_VISIBILITY
247
0
    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
248
249
    _LIBCPP_INLINE_VISIBILITY
250
    error_condition(int __val, const error_category& __cat) _NOEXCEPT
251
597
        : __val_(__val), __cat_(&__cat) {}
252
253
    template <class _Ep>
254
        _LIBCPP_INLINE_VISIBILITY
255
        error_condition(_Ep __e,
256
              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
257
                                                                     ) _NOEXCEPT
258
593
            {*this = make_error_condition(__e);}
259
260
    _LIBCPP_INLINE_VISIBILITY
261
    void assign(int __val, const error_category& __cat) _NOEXCEPT
262
0
    {
263
0
        __val_ = __val;
264
0
        __cat_ = &__cat;
265
0
    }
266
267
    template <class _Ep>
268
        _LIBCPP_INLINE_VISIBILITY
269
        typename enable_if
270
        <
271
            is_error_condition_enum<_Ep>::value,
272
            error_condition&
273
        >::type
274
        operator=(_Ep __e) _NOEXCEPT
275
            {*this = make_error_condition(__e); return *this;}
276
277
    _LIBCPP_INLINE_VISIBILITY
278
    void clear() _NOEXCEPT
279
0
    {
280
0
        __val_ = 0;
281
0
        __cat_ = &generic_category();
282
0
    }
283
284
    _LIBCPP_INLINE_VISIBILITY
285
16
    int value() const _NOEXCEPT {return __val_;}
286
287
    _LIBCPP_INLINE_VISIBILITY
288
16
    const error_category& category() const _NOEXCEPT {return *__cat_;}
289
    string message() const;
290
291
    _LIBCPP_INLINE_VISIBILITY
292
        _LIBCPP_EXPLICIT
293
0
        operator bool() const _NOEXCEPT {return __val_ != 0;}
294
};
295
296
inline _LIBCPP_INLINE_VISIBILITY
297
error_condition
298
make_error_condition(errc __e) _NOEXCEPT
299
593
{
300
593
    return error_condition(static_cast<int>(__e), generic_category());
301
593
}
302
303
inline _LIBCPP_INLINE_VISIBILITY
304
bool
305
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
306
0
{
307
0
    return __x.category() < __y.category()
308
0
        || (__x.category() == __y.category() && __x.value() < __y.value());
309
0
}
310
311
// error_code
312
313
class _LIBCPP_TYPE_VIS error_code
314
{
315
    int __val_;
316
    const error_category* __cat_;
317
public:
318
    _LIBCPP_INLINE_VISIBILITY
319
31.0M
    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
320
321
    _LIBCPP_INLINE_VISIBILITY
322
    error_code(int __val, const error_category& __cat) _NOEXCEPT
323
48.7M
        : __val_(__val), __cat_(&__cat) {}
324
325
    template <class _Ep>
326
        _LIBCPP_INLINE_VISIBILITY
327
        error_code(_Ep __e,
328
                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
329
                                                                     ) _NOEXCEPT
330
0
            {*this = make_error_code(__e);}
331
332
    _LIBCPP_INLINE_VISIBILITY
333
    void assign(int __val, const error_category& __cat) _NOEXCEPT
334
0
    {
335
0
        __val_ = __val;
336
0
        __cat_ = &__cat;
337
0
    }
338
339
    template <class _Ep>
340
        _LIBCPP_INLINE_VISIBILITY
341
        typename enable_if
342
        <
343
            is_error_code_enum<_Ep>::value,
344
            error_code&
345
        >::type
346
        operator=(_Ep __e) _NOEXCEPT
347
            {*this = make_error_code(__e); return *this;}
348
349
    _LIBCPP_INLINE_VISIBILITY
350
    void clear() _NOEXCEPT
351
0
    {
352
0
        __val_ = 0;
353
0
        __cat_ = &system_category();
354
0
    }
355
356
    _LIBCPP_INLINE_VISIBILITY
357
11.1M
    int value() const _NOEXCEPT {return __val_;}
358
359
    _LIBCPP_INLINE_VISIBILITY
360
25.8M
    const error_category& category() const _NOEXCEPT {return *__cat_;}
361
362
    _LIBCPP_INLINE_VISIBILITY
363
    error_condition default_error_condition() const _NOEXCEPT
364
0
        {return __cat_->default_error_condition(__val_);}
365
366
    string message() const;
367
368
    _LIBCPP_INLINE_VISIBILITY
369
        _LIBCPP_EXPLICIT
370
35.2M
        operator bool() const _NOEXCEPT {return __val_ != 0;}
371
};
372
373
inline _LIBCPP_INLINE_VISIBILITY
374
error_code
375
make_error_code(errc __e) _NOEXCEPT
376
29.9M
{
377
29.9M
    return error_code(static_cast<int>(__e), generic_category());
378
29.9M
}
379
380
inline _LIBCPP_INLINE_VISIBILITY
381
bool
382
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
383
0
{
384
0
    return __x.category() < __y.category()
385
0
        || (__x.category() == __y.category() && __x.value() < __y.value());
386
0
}
387
388
inline _LIBCPP_INLINE_VISIBILITY
389
bool
390
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
391
{
392
    return __x.category() == __y.category() && __x.value() == __y.value();
393
}
394
395
inline _LIBCPP_INLINE_VISIBILITY
396
bool
397
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
398
593
{
399
593
    return __x.category().equivalent(__x.value(), __y)
400
593
        || 
__y.category().equivalent(__x, __y.value())8
;
401
593
}
402
403
inline _LIBCPP_INLINE_VISIBILITY
404
bool
405
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
406
0
{
407
0
    return __y == __x;
408
0
}
409
410
inline _LIBCPP_INLINE_VISIBILITY
411
bool
412
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
413
4
{
414
4
    return __x.category() == __y.category() && __x.value() == __y.value();
415
4
}
416
417
inline _LIBCPP_INLINE_VISIBILITY
418
bool
419
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
420
{return !(__x == __y);}
421
422
inline _LIBCPP_INLINE_VISIBILITY
423
bool
424
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
425
0
{return !(__x == __y);}
426
427
inline _LIBCPP_INLINE_VISIBILITY
428
bool
429
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
430
0
{return !(__x == __y);}
431
432
inline _LIBCPP_INLINE_VISIBILITY
433
bool
434
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
435
0
{return !(__x == __y);}
436
437
template <>
438
struct _LIBCPP_TEMPLATE_VIS hash<error_code>
439
    : public unary_function<error_code, size_t>
440
{
441
    _LIBCPP_INLINE_VISIBILITY
442
    size_t operator()(const error_code& __ec) const _NOEXCEPT
443
0
    {
444
0
        return static_cast<size_t>(__ec.value());
445
0
    }
446
};
447
448
template <>
449
struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
450
    : public unary_function<error_condition, size_t>
451
{
452
    _LIBCPP_INLINE_VISIBILITY
453
    size_t operator()(const error_condition& __ec) const _NOEXCEPT
454
0
    {
455
0
        return static_cast<size_t>(__ec.value());
456
0
    }
457
};
458
459
// system_error
460
461
class _LIBCPP_TYPE_VIS system_error
462
    : public runtime_error
463
{
464
    error_code __ec_;
465
public:
466
    system_error(error_code __ec, const string& __what_arg);
467
    system_error(error_code __ec, const char* __what_arg);
468
    system_error(error_code __ec);
469
    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
470
    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
471
    system_error(int __ev, const error_category& __ecat);
472
    ~system_error() _NOEXCEPT;
473
474
    _LIBCPP_INLINE_VISIBILITY
475
0
    const error_code& code() const _NOEXCEPT {return __ec_;}
476
477
private:
478
    static string __init(const error_code&, string);
479
};
480
481
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
482
void __throw_system_error(int ev, const char* what_arg);
483
484
_LIBCPP_END_NAMESPACE_STD
485
486
#endif  // _LIBCPP_SYSTEM_ERROR