path: root/contrib/libs/cxxsupp/libcxx/include/system_error

// -*- C++ -*- 
//===---------------------------- system_error ----------------------------===// 
// 
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// 
//===----------------------------------------------------------------------===// 
 
#ifndef _LIBCPP_SYSTEM_ERROR 
#define _LIBCPP_SYSTEM_ERROR 
 
/* 
    system_error synopsis 
 
namespace std 
{ 
 
class error_category 
{ 
public: 
    virtual ~error_category() noexcept; 
 
    constexpr error_category(); 
    error_category(const error_category&) = delete; 
    error_category& operator=(const error_category&) = delete; 
 
    virtual const char* name() const noexcept = 0; 
    virtual error_condition default_error_condition(int ev) const noexcept; 
    virtual bool equivalent(int code, const error_condition& condition) const noexcept; 
    virtual bool equivalent(const error_code& code, int condition) const noexcept; 
    virtual string message(int ev) const = 0; 
 
    bool operator==(const error_category& rhs) const noexcept; 
    bool operator!=(const error_category& rhs) const noexcept; 
    bool operator<(const error_category& rhs) const noexcept; 
}; 
 
const error_category& generic_category() noexcept; 
const error_category& system_category() noexcept; 
 
template <class T> struct is_error_code_enum 
    : public false_type {}; 
 
template <class T> struct is_error_condition_enum 
    : public false_type {}; 
 
template <class _Tp> 
inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17 
 
template <class _Tp> 
inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17 
 
class error_code 
{ 
public: 
    // constructors: 
    error_code() noexcept; 
    error_code(int val, const error_category& cat) noexcept; 
    template <class ErrorCodeEnum> 
        error_code(ErrorCodeEnum e) noexcept; 
 
    // modifiers: 
    void assign(int val, const error_category& cat) noexcept; 
    template <class ErrorCodeEnum> 
        error_code& operator=(ErrorCodeEnum e) noexcept; 
    void clear() noexcept; 
 
    // observers: 
    int value() const noexcept; 
    const error_category& category() const noexcept; 
    error_condition default_error_condition() const noexcept; 
    string message() const; 
    explicit operator bool() const noexcept; 
}; 
 
// non-member functions: 
bool operator<(const error_code& lhs, const error_code& rhs) noexcept; 
template <class charT, class traits> 
    basic_ostream<charT,traits>& 
    operator<<(basic_ostream<charT,traits>& os, const error_code& ec); 
 
class error_condition 
{ 
public: 
    // constructors: 
    error_condition() noexcept; 
    error_condition(int val, const error_category& cat) noexcept; 
    template <class ErrorConditionEnum> 
        error_condition(ErrorConditionEnum e) noexcept; 
 
    // modifiers: 
    void assign(int val, const error_category& cat) noexcept; 
    template <class ErrorConditionEnum> 
        error_condition& operator=(ErrorConditionEnum e) noexcept; 
    void clear() noexcept; 
 
    // observers: 
    int value() const noexcept; 
    const error_category& category() const noexcept; 
    string message() const noexcept; 
    explicit operator bool() const noexcept; 
}; 
 
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; 
 
class system_error 
    : public runtime_error 
{ 
public: 
    system_error(error_code ec, const string& what_arg); 
    system_error(error_code ec, const char* what_arg); 
    system_error(error_code ec); 
    system_error(int ev, const error_category& ecat, const string& what_arg); 
    system_error(int ev, const error_category& ecat, const char* what_arg); 
    system_error(int ev, const error_category& ecat); 
 
    const error_code& code() const noexcept; 
    const char* what() const noexcept; 
}; 
 
template <> struct is_error_condition_enum<errc> 
    : true_type { } 
 
error_code make_error_code(errc e) noexcept; 
error_condition make_error_condition(errc e) noexcept; 
 
// Comparison operators: 
bool operator==(const error_code& lhs, const error_code& rhs) noexcept; 
bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; 
bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; 
bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; 
bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; 
bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; 
bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; 
bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; 
 
template <> struct hash<std::error_code>; 
template <> struct hash<std::error_condition>;
 
}  // std 
 
*/ 
 
#include <__config> 
#include <__errc> 
#include <__functional/unary_function.h> 
#include <__functional_base> 
#include <compare> 
#include <stdexcept> 
#include <string> 
#include <type_traits> 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
// is_error_code_enum 
 
template <class _Tp> 
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum 
    : public false_type {}; 
 
#if _LIBCPP_STD_VER > 14 
template <class _Tp> 
inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; 
#endif 
 
// is_error_condition_enum 
 
template <class _Tp> 
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum 
    : public false_type {}; 
 
#if _LIBCPP_STD_VER > 14 
template <class _Tp> 
inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; 
#endif 
 
template <> 
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> 
    : true_type { }; 
 
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 
template <> 
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> 
    : true_type { }; 
#endif 
 
class _LIBCPP_TYPE_VIS error_condition; 
class _LIBCPP_TYPE_VIS error_code; 
 
// class error_category 
 
class _LIBCPP_HIDDEN __do_message; 
 
class _LIBCPP_TYPE_VIS error_category 
{ 
public: 
    virtual ~error_category() _NOEXCEPT; 
 
// ODR violation is used for binary compatibility with older versions of libc++. 
// We don't have old libc++ versions for MSVC, so we don't need it. 
#if defined(_LIBCPP_BUILDING_LIBRARY) && \
    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 
    error_category() _NOEXCEPT; 
#else 
    _LIBCPP_INLINE_VISIBILITY 
    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT 
#endif 
private: 
    error_category(const error_category&);// = delete; 
    error_category& operator=(const error_category&);// = delete; 
 
public: 
    virtual const char* name() const _NOEXCEPT = 0; 
    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; 
    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; 
    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; 
    virtual string message(int __ev) const = 0; 
 
    _LIBCPP_INLINE_VISIBILITY 
    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} 
 
    _LIBCPP_INLINE_VISIBILITY 
    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} 
 
    friend class _LIBCPP_HIDDEN __do_message; 
}; 
 
class _LIBCPP_HIDDEN __do_message 
    : public error_category 
{ 
public: 
    virtual string message(int ev) const; 
}; 
 
_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; 
_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; 
 
class _LIBCPP_TYPE_VIS error_condition 
{ 
    int __val_; 
    const error_category* __cat_; 
public: 
    _LIBCPP_INLINE_VISIBILITY 
    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} 
 
    _LIBCPP_INLINE_VISIBILITY 
    error_condition(int __val, const error_category& __cat) _NOEXCEPT 
        : __val_(__val), __cat_(&__cat) {} 
 
    template <class _Ep> 
        _LIBCPP_INLINE_VISIBILITY 
        error_condition(_Ep __e, 
              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr 
                                                                     ) _NOEXCEPT 
            {*this = make_error_condition(__e);} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void assign(int __val, const error_category& __cat) _NOEXCEPT 
    { 
        __val_ = __val; 
        __cat_ = &__cat; 
    } 
 
    template <class _Ep> 
        _LIBCPP_INLINE_VISIBILITY 
        typename enable_if 
        < 
            is_error_condition_enum<_Ep>::value, 
            error_condition& 
        >::type 
        operator=(_Ep __e) _NOEXCEPT 
            {*this = make_error_condition(__e); return *this;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void clear() _NOEXCEPT 
    { 
        __val_ = 0; 
        __cat_ = &generic_category(); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    int value() const _NOEXCEPT {return __val_;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    const error_category& category() const _NOEXCEPT {return *__cat_;} 
    string message() const; 
 
    _LIBCPP_INLINE_VISIBILITY 
    explicit operator bool() const _NOEXCEPT {return __val_ != 0;} 
}; 
 
inline _LIBCPP_INLINE_VISIBILITY 
error_condition 
make_error_condition(errc __e) _NOEXCEPT 
{ 
    return error_condition(static_cast<int>(__e), generic_category()); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
{ 
    return __x.category() < __y.category() 
        || (__x.category() == __y.category() && __x.value() < __y.value()); 
} 
 
// error_code 
 
class _LIBCPP_TYPE_VIS error_code 
{ 
    int __val_; 
    const error_category* __cat_; 
public: 
    _LIBCPP_INLINE_VISIBILITY 
    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} 
 
    _LIBCPP_INLINE_VISIBILITY 
    error_code(int __val, const error_category& __cat) _NOEXCEPT 
        : __val_(__val), __cat_(&__cat) {} 
 
    template <class _Ep> 
        _LIBCPP_INLINE_VISIBILITY 
        error_code(_Ep __e, 
                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr 
                                                                     ) _NOEXCEPT 
            {*this = make_error_code(__e);} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void assign(int __val, const error_category& __cat) _NOEXCEPT 
    { 
        __val_ = __val; 
        __cat_ = &__cat; 
    } 
 
    template <class _Ep> 
        _LIBCPP_INLINE_VISIBILITY 
        typename enable_if 
        < 
            is_error_code_enum<_Ep>::value, 
            error_code& 
        >::type 
        operator=(_Ep __e) _NOEXCEPT 
            {*this = make_error_code(__e); return *this;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void clear() _NOEXCEPT 
    { 
        __val_ = 0; 
        __cat_ = &system_category(); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    int value() const _NOEXCEPT {return __val_;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    const error_category& category() const _NOEXCEPT {return *__cat_;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    error_condition default_error_condition() const _NOEXCEPT 
        {return __cat_->default_error_condition(__val_);} 
 
    string message() const; 
 
    _LIBCPP_INLINE_VISIBILITY 
    explicit operator bool() const _NOEXCEPT {return __val_ != 0;} 
}; 
 
inline _LIBCPP_INLINE_VISIBILITY 
error_code 
make_error_code(errc __e) _NOEXCEPT 
{ 
    return error_code(static_cast<int>(__e), generic_category()); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT 
{ 
    return __x.category() < __y.category() 
        || (__x.category() == __y.category() && __x.value() < __y.value()); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT 
{ 
    return __x.category() == __y.category() && __x.value() == __y.value(); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT 
{ 
    return __x.category().equivalent(__x.value(), __y) 
        || __y.category().equivalent(__x, __y.value()); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT 
{ 
    return __y == __x; 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
{ 
    return __x.category() == __y.category() && __x.value() == __y.value(); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT 
{return !(__x == __y);} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT 
{return !(__x == __y);} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT 
{return !(__x == __y);} 
 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
{return !(__x == __y);} 
 
template <> 
struct _LIBCPP_TEMPLATE_VIS hash<error_code> 
    : public unary_function<error_code, size_t> 
{ 
    _LIBCPP_INLINE_VISIBILITY 
    size_t operator()(const error_code& __ec) const _NOEXCEPT 
    { 
        return static_cast<size_t>(__ec.value()); 
    } 
}; 
 
template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_condition> 
    : public unary_function<error_condition, size_t>
{
    _LIBCPP_INLINE_VISIBILITY
    size_t operator()(const error_condition& __ec) const _NOEXCEPT
    {
        return static_cast<size_t>(__ec.value());
    }
};

// system_error 
 
class _LIBCPP_TYPE_VIS system_error 
    : public runtime_error 
{ 
    error_code __ec_; 
public: 
    system_error(error_code __ec, const string& __what_arg); 
    system_error(error_code __ec, const char* __what_arg); 
    system_error(error_code __ec); 
    system_error(int __ev, const error_category& __ecat, const string& __what_arg); 
    system_error(int __ev, const error_category& __ecat, const char* __what_arg); 
    system_error(int __ev, const error_category& __ecat); 
    system_error(const system_error&) _NOEXCEPT = default; 
    ~system_error() _NOEXCEPT; 
 
    _LIBCPP_INLINE_VISIBILITY 
    const error_code& code() const _NOEXCEPT {return __ec_;} 
 
private: 
    static string __init(const error_code&, string); 
}; 
 
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS 
void __throw_system_error(int ev, const char* what_arg); 
 
_LIBCPP_END_NAMESPACE_STD 
 
#endif // _LIBCPP_SYSTEM_ERROR