1 // <system_error> -*- C++ -*- 2 3 // Copyright (C) 2007-2014 Free Software Foundation, Inc. 4 // 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) 9 // any later version. 10 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. 15 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. 19 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/>. 24 25 /** @file include/system_error 26 * This is a Standard C++ Library header. 27 */ 28 29 #ifndef _GLIBCXX_SYSTEM_ERROR 30 #define _GLIBCXX_SYSTEM_ERROR 1 31 32 #pragma GCC system_header 33 34 #if __cplusplus < 201103L 35 # include <bits/c++0x_warning.h> 36 #else 37 38 #include <bits/c++config.h> 39 #include <bits/error_constants.h> 40 #include <iosfwd> 41 #include <stdexcept> 42 43 namespace std _GLIBCXX_VISIBILITY(default) 44 { 45 _GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 class error_code; 48 class error_condition; 49 class error_category; 50 class system_error; 51 52 /// is_error_code_enum 53 template<typename _Tp> 54 struct is_error_code_enum : public false_type { }; 55 56 /// is_error_condition_enum 57 template<typename _Tp> 58 struct is_error_condition_enum : public false_type { }; 59 60 template<> 61 struct is_error_condition_enum<errc> 62 : public true_type { }; 63 64 65 /// error_category 66 class error_category 67 { 68 public: 69 #ifdef _GLIBCXX_COMPATIBILITY_CXX0X 70 error_category() noexcept; 71 #else 72 constexpr error_category() noexcept = default; 73 #endif 74 75 virtual ~error_category(); 76 77 error_category(const error_category&) = delete; 78 error_category& operator=(const error_category&) = delete; 79 80 virtual const char* 81 name() const noexcept = 0; 82 83 virtual string 84 message(int) const = 0; 85 86 virtual error_condition 87 default_error_condition(int __i) const noexcept; 88 89 virtual bool 90 equivalent(int __i, const error_condition& __cond) const noexcept; 91 92 virtual bool 93 equivalent(const error_code& __code, int __i) const noexcept; 94 95 bool 96 operator<(const error_category& __other) const noexcept 97 { return less<const error_category*>()(this, &__other); } 98 99 bool 100 operator==(const error_category& __other) const noexcept 101 { return this == &__other; } 102 103 bool 104 operator!=(const error_category& __other) const noexcept 105 { return this != &__other; } 106 }; 107 108 // DR 890. 109 _GLIBCXX_CONST const error_category& system_category() noexcept; 110 _GLIBCXX_CONST const error_category& generic_category() noexcept; 111 112 error_code make_error_code(errc) noexcept; 113 114 template<typename _Tp> 115 struct hash; 116 117 /// error_code 118 // Implementation-specific error identification 119 struct error_code 120 { 121 error_code() noexcept 122 : _M_value(0), _M_cat(&system_category()) { } 123 124 error_code(int __v, const error_category& __cat) noexcept 125 : _M_value(__v), _M_cat(&__cat) { } 126 127 template<typename _ErrorCodeEnum, typename = typename 128 enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type> 129 error_code(_ErrorCodeEnum __e) noexcept 130 { *this = make_error_code(__e); } 131 132 void 133 assign(int __v, const error_category& __cat) noexcept 134 { 135 _M_value = __v; 136 _M_cat = &__cat; 137 } 138 139 void 140 clear() noexcept 141 { assign(0, system_category()); } 142 143 // DR 804. 144 template<typename _ErrorCodeEnum> 145 typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value, 146 error_code&>::type 147 operator=(_ErrorCodeEnum __e) noexcept 148 { return *this = make_error_code(__e); } 149 150 int 151 value() const noexcept { return _M_value; } 152 153 const error_category& 154 category() const noexcept { return *_M_cat; } 155 156 error_condition 157 default_error_condition() const noexcept; 158 159 string 160 message() const 161 { return category().message(value()); } 162 163 explicit operator bool() const noexcept 164 { return _M_value != 0 ? true : false; } 165 166 // DR 804. 167 private: 168 friend class hash<error_code>; 169 170 int _M_value; 171 const error_category* _M_cat; 172 }; 173 174 // 19.4.2.6 non-member functions 175 inline error_code 176 make_error_code(errc __e) noexcept 177 { return error_code(static_cast<int>(__e), generic_category()); } 178 179 inline bool 180 operator<(const error_code& __lhs, const error_code& __rhs) noexcept 181 { 182 return (__lhs.category() < __rhs.category() 183 || (__lhs.category() == __rhs.category() 184 && __lhs.value() < __rhs.value())); 185 } 186 187 template<typename _CharT, typename _Traits> 188 basic_ostream<_CharT, _Traits>& 189 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) 190 { return (__os << __e.category().name() << ':' << __e.value()); } 191 192 error_condition make_error_condition(errc) noexcept; 193 194 /// error_condition 195 // Portable error identification 196 struct error_condition 197 { 198 error_condition() noexcept 199 : _M_value(0), _M_cat(&generic_category()) { } 200 201 error_condition(int __v, const error_category& __cat) noexcept 202 : _M_value(__v), _M_cat(&__cat) { } 203 204 template<typename _ErrorConditionEnum, typename = typename 205 enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type> 206 error_condition(_ErrorConditionEnum __e) noexcept 207 { *this = make_error_condition(__e); } 208 209 void 210 assign(int __v, const error_category& __cat) noexcept 211 { 212 _M_value = __v; 213 _M_cat = &__cat; 214 } 215 216 // DR 804. 217 template<typename _ErrorConditionEnum> 218 typename enable_if<is_error_condition_enum 219 <_ErrorConditionEnum>::value, error_condition&>::type 220 operator=(_ErrorConditionEnum __e) noexcept 221 { return *this = make_error_condition(__e); } 222 223 void 224 clear() noexcept 225 { assign(0, generic_category()); } 226 227 // 19.4.3.4 observers 228 int 229 value() const noexcept { return _M_value; } 230 231 const error_category& 232 category() const noexcept { return *_M_cat; } 233 234 string 235 message() const 236 { return category().message(value()); } 237 238 explicit operator bool() const noexcept 239 { return _M_value != 0 ? true : false; } 240 241 // DR 804. 242 private: 243 int _M_value; 244 const error_category* _M_cat; 245 }; 246 247 // 19.4.3.6 non-member functions 248 inline error_condition 249 make_error_condition(errc __e) noexcept 250 { return error_condition(static_cast<int>(__e), generic_category()); } 251 252 inline bool 253 operator<(const error_condition& __lhs, 254 const error_condition& __rhs) noexcept 255 { 256 return (__lhs.category() < __rhs.category() 257 || (__lhs.category() == __rhs.category() 258 && __lhs.value() < __rhs.value())); 259 } 260 261 // 19.4.4 Comparison operators 262 inline bool 263 operator==(const error_code& __lhs, const error_code& __rhs) noexcept 264 { return (__lhs.category() == __rhs.category() 265 && __lhs.value() == __rhs.value()); } 266 267 inline bool 268 operator==(const error_code& __lhs, const error_condition& __rhs) noexcept 269 { 270 return (__lhs.category().equivalent(__lhs.value(), __rhs) 271 || __rhs.category().equivalent(__lhs, __rhs.value())); 272 } 273 274 inline bool 275 operator==(const error_condition& __lhs, const error_code& __rhs) noexcept 276 { 277 return (__rhs.category().equivalent(__rhs.value(), __lhs) 278 || __lhs.category().equivalent(__rhs, __lhs.value())); 279 } 280 281 inline bool 282 operator==(const error_condition& __lhs, 283 const error_condition& __rhs) noexcept 284 { 285 return (__lhs.category() == __rhs.category() 286 && __lhs.value() == __rhs.value()); 287 } 288 289 inline bool 290 operator!=(const error_code& __lhs, const error_code& __rhs) noexcept 291 { return !(__lhs == __rhs); } 292 293 inline bool 294 operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept 295 { return !(__lhs == __rhs); } 296 297 inline bool 298 operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept 299 { return !(__lhs == __rhs); } 300 301 inline bool 302 operator!=(const error_condition& __lhs, 303 const error_condition& __rhs) noexcept 304 { return !(__lhs == __rhs); } 305 306 307 /** 308 * @brief Thrown to indicate error code of underlying system. 309 * 310 * @ingroup exceptions 311 */ 312 class system_error : public std::runtime_error 313 { 314 private: 315 error_code _M_code; 316 317 public: 318 system_error(error_code __ec = error_code()) 319 : runtime_error(__ec.message()), _M_code(__ec) { } 320 321 system_error(error_code __ec, const string& __what) 322 : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } 323 324 /* 325 * TODO: Add const char* ctors to all exceptions. 326 * 327 * system_error(error_code __ec, const char* __what) 328 * : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } 329 * 330 * system_error(int __v, const error_category& __ecat, const char* __what) 331 * : runtime_error(__what + (": " + __ec.message())), 332 * _M_code(error_code(__v, __ecat)) { } 333 */ 334 335 system_error(int __v, const error_category& __ecat) 336 : runtime_error(error_code(__v, __ecat).message()), 337 _M_code(__v, __ecat) { } 338 339 system_error(int __v, const error_category& __ecat, const string& __what) 340 : runtime_error(__what + ": " + error_code(__v, __ecat).message()), 341 _M_code(__v, __ecat) { } 342 343 virtual ~system_error() noexcept; 344 345 const error_code& 346 code() const noexcept { return _M_code; } 347 }; 348 349 _GLIBCXX_END_NAMESPACE_VERSION 350 } // namespace 351 352 #ifndef _GLIBCXX_COMPATIBILITY_CXX0X 353 354 #include <bits/functional_hash.h> 355 356 namespace std _GLIBCXX_VISIBILITY(default) 357 { 358 _GLIBCXX_BEGIN_NAMESPACE_VERSION 359 360 // DR 1182. 361 /// std::hash specialization for error_code. 362 template<> 363 struct hash<error_code> 364 : public __hash_base<size_t, error_code> 365 { 366 size_t 367 operator()(const error_code& __e) const noexcept 368 { 369 const size_t __tmp = std::_Hash_impl::hash(__e._M_value); 370 return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); 371 } 372 }; 373 374 _GLIBCXX_END_NAMESPACE_VERSION 375 } // namespace 376 377 #endif // _GLIBCXX_COMPATIBILITY_CXX0X 378 379 #endif // C++11 380 381 #endif // _GLIBCXX_SYSTEM_ERROR 382
