Home | History | Annotate | Download | only in include 
      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 
     17 namespace std
     18 {
     19 
     20 class error_category
     21 {
     22 public:
     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 
     40 const error_category& generic_category() noexcept;
     41 const error_category& system_category() noexcept;
     42 
     43 template <class T> struct is_error_code_enum
     44     : public false_type {};
     45 
     46 template <class T> struct is_error_condition_enum
     47     : public false_type {};
     48 
     49 template <class _Tp>
     50 inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
     51 
     52 template <class _Tp>
     53 inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
     54 
     55 class error_code
     56 {
     57 public:
     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:
     79 bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
     80 template <class charT, class traits>
     81     basic_ostream<charT,traits>&
     82     operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
     83 
     84 class error_condition
     85 {
     86 public:
     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 
    106 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
    107 
    108 class system_error
    109     : public runtime_error
    110 {
    111 public:
    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 
    123 template <> struct is_error_condition_enum<errc>
    124     : true_type { }
    125 
    126 error_code make_error_code(errc e) noexcept;
    127 error_condition make_error_condition(errc e) noexcept;
    128 
    129 // Comparison operators:
    130 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
    131 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
    132 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
    133 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
    134 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
    135 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
    136 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
    137 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
    138 
    139 template <> struct hash<std::error_code>;
    140 template <> 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 
    160 template <class _Tp>
    161 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
    162     : public false_type {};
    163 
    164 #if _LIBCPP_STD_VER > 14
    165 template <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 
    171 template <class _Tp>
    172 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
    173     : public false_type {};
    174 
    175 #if _LIBCPP_STD_VER > 14
    176 template <class _Tp>
    177 _LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
    178 #endif
    179 
    180 template <>
    181 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
    182     : true_type { };
    183 
    184 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
    185 template <>
    186 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
    187     : true_type { };
    188 #endif
    189 
    190 class _LIBCPP_TYPE_VIS error_condition;
    191 class _LIBCPP_TYPE_VIS error_code;
    192 
    193 // class error_category
    194 
    195 class _LIBCPP_HIDDEN __do_message;
    196 
    197 class _LIBCPP_TYPE_VIS error_category
    198 {
    199 public:
    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
    209 private:
    210     error_category(const error_category&);// = delete;
    211     error_category& operator=(const error_category&);// = delete;
    212 
    213 public:
    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 
    232 class _LIBCPP_HIDDEN __do_message
    233     : public error_category
    234 {
    235 public:
    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 
    242 class _LIBCPP_TYPE_VIS error_condition
    243 {
    244     int __val_;
    245     const error_category* __cat_;
    246 public:
    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 
    297 inline _LIBCPP_INLINE_VISIBILITY
    298 error_condition
    299 make_error_condition(errc __e) _NOEXCEPT
    300 {
    301     return error_condition(static_cast<int>(__e), generic_category());
    302 }
    303 
    304 inline _LIBCPP_INLINE_VISIBILITY
    305 bool
    306 operator<(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 
    314 class _LIBCPP_TYPE_VIS error_code
    315 {
    316     int __val_;
    317     const error_category* __cat_;
    318 public:
    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 
    374 inline _LIBCPP_INLINE_VISIBILITY
    375 error_code
    376 make_error_code(errc __e) _NOEXCEPT
    377 {
    378     return error_code(static_cast<int>(__e), generic_category());
    379 }
    380 
    381 inline _LIBCPP_INLINE_VISIBILITY
    382 bool
    383 operator<(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 
    389 inline _LIBCPP_INLINE_VISIBILITY
    390 bool
    391 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
    392 {
    393     return __x.category() == __y.category() && __x.value() == __y.value();
    394 }
    395 
    396 inline _LIBCPP_INLINE_VISIBILITY
    397 bool
    398 operator==(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 
    404 inline _LIBCPP_INLINE_VISIBILITY
    405 bool
    406 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
    407 {
    408     return __y == __x;
    409 }
    410 
    411 inline _LIBCPP_INLINE_VISIBILITY
    412 bool
    413 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
    414 {
    415     return __x.category() == __y.category() && __x.value() == __y.value();
    416 }
    417 
    418 inline _LIBCPP_INLINE_VISIBILITY
    419 bool
    420 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
    421 {return !(__x == __y);}
    422 
    423 inline _LIBCPP_INLINE_VISIBILITY
    424 bool
    425 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
    426 {return !(__x == __y);}
    427 
    428 inline _LIBCPP_INLINE_VISIBILITY
    429 bool
    430 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
    431 {return !(__x == __y);}
    432 
    433 inline _LIBCPP_INLINE_VISIBILITY
    434 bool
    435 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
    436 {return !(__x == __y);}
    437 
    438 template <>
    439 struct _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 
    449 template <>
    450 struct _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 
    462 class _LIBCPP_TYPE_VIS system_error
    463     : public runtime_error
    464 {
    465     error_code __ec_;
    466 public:
    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 
    478 private:
    479     static string __init(const error_code&, string);
    480 };
    481 
    482 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
    483 void __throw_system_error(int ev, const char* what_arg);
    484 
    485 _LIBCPP_END_NAMESPACE_STD
    486 
    487 #endif  // _LIBCPP_SYSTEM_ERROR
    488