include/system_error

// -*- C++ -*-
//===---------------------------- system_error ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#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 {};

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;
};

enum class errc
{
 address_family_not_supported, // EAFNOSUPPORT
 address_in_use, // EADDRINUSE
 address_not_available, // EADDRNOTAVAIL
 already_connected, // EISCONN
 argument_list_too_long, // E2BIG
 argument_out_of_domain, // EDOM
 bad_address, // EFAULT
 bad_file_descriptor, // EBADF
 bad_message, // EBADMSG
 broken_pipe, // EPIPE
 connection_aborted, // ECONNABORTED
 connection_already_in_progress, // EALREADY
 connection_refused, // ECONNREFUSED
 connection_reset, // ECONNRESET
 cross_device_link, // EXDEV
 destination_address_required, // EDESTADDRREQ
 device_or_resource_busy, // EBUSY
 directory_not_empty, // ENOTEMPTY
 executable_format_error, // ENOEXEC
 file_exists, // EEXIST
 file_too_large, // EFBIG
 filename_too_long, // ENAMETOOLONG
 function_not_supported, // ENOSYS
 host_unreachable, // EHOSTUNREACH
 identifier_removed, // EIDRM
 illegal_byte_sequence, // EILSEQ
 inappropriate_io_control_operation, // ENOTTY
 interrupted, // EINTR
 invalid_argument, // EINVAL
 invalid_seek, // ESPIPE
 io_error, // EIO
 is_a_directory, // EISDIR
 message_size, // EMSGSIZE
 network_down, // ENETDOWN
 network_reset, // ENETRESET
 network_unreachable, // ENETUNREACH
 no_buffer_space, // ENOBUFS
 no_child_process, // ECHILD
 no_link, // ENOLINK
 no_lock_available, // ENOLCK
 no_message_available, // ENODATA
 no_message, // ENOMSG
 no_protocol_option, // ENOPROTOOPT
 no_space_on_device, // ENOSPC
 no_stream_resources, // ENOSR
 no_such_device_or_address, // ENXIO
 no_such_device, // ENODEV
 no_such_file_or_directory, // ENOENT
 no_such_process, // ESRCH
 not_a_directory, // ENOTDIR
 not_a_socket, // ENOTSOCK
 not_a_stream, // ENOSTR
 not_connected, // ENOTCONN
 not_enough_memory, // ENOMEM
 not_supported, // ENOTSUP
 operation_canceled, // ECANCELED
 operation_in_progress, // EINPROGRESS
 operation_not_permitted, // EPERM
 operation_not_supported, // EOPNOTSUPP
 operation_would_block, // EWOULDBLOCK
 owner_dead, // EOWNERDEAD
 permission_denied, // EACCES
 protocol_error, // EPROTO
 protocol_not_supported, // EPROTONOSUPPORT
 read_only_file_system, // EROFS
 resource_deadlock_would_occur, // EDEADLK
 resource_unavailable_try_again, // EAGAIN
 result_out_of_range, // ERANGE
 state_not_recoverable, // ENOTRECOVERABLE
 stream_timeout, // ETIME
 text_file_busy, // ETXTBSY
 timed_out, // ETIMEDOUT
 too_many_files_open_in_system, // ENFILE
 too_many_files_open, // EMFILE
 too_many_links, // EMLINK
 too_many_symbolic_link_levels, // ELOOP
 value_too_large, // EOVERFLOW
 wrong_protocol_type // EPROTOTYPE
};

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>;

} // std

*/

#include <__config>
#include <cerrno>
#include <type_traits>
#include <stdexcept>
#include <__functional_base>

#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_TYPE_VIS_ONLY is_error_code_enum
 : public false_type {};

// is_error_condition_enum

template <class _Tp>
struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum
 : public false_type {};

// Some error codes are not present on all platforms, so we provide equivalents
// for them:

//enum class errc
_LIBCPP_DECLARE_STRONG_ENUM(errc)
{
 address_family_not_supported = EAFNOSUPPORT,
 address_in_use = EADDRINUSE,
 address_not_available = EADDRNOTAVAIL,
 already_connected = EISCONN,
 argument_list_too_long = E2BIG,
 argument_out_of_domain = EDOM,
 bad_address = EFAULT,
 bad_file_descriptor = EBADF,
 bad_message = EBADMSG,
 broken_pipe = EPIPE,
 connection_aborted = ECONNABORTED,
 connection_already_in_progress = EALREADY,
 connection_refused = ECONNREFUSED,
 connection_reset = ECONNRESET,
 cross_device_link = EXDEV,
 destination_address_required = EDESTADDRREQ,
 device_or_resource_busy = EBUSY,
 directory_not_empty = ENOTEMPTY,
 executable_format_error = ENOEXEC,
 file_exists = EEXIST,
 file_too_large = EFBIG,
 filename_too_long = ENAMETOOLONG,
 function_not_supported = ENOSYS,
 host_unreachable = EHOSTUNREACH,
 identifier_removed = EIDRM,
 illegal_byte_sequence = EILSEQ,
 inappropriate_io_control_operation = ENOTTY,
 interrupted = EINTR,
 invalid_argument = EINVAL,
 invalid_seek = ESPIPE,
 io_error = EIO,
 is_a_directory = EISDIR,
 message_size = EMSGSIZE,
 network_down = ENETDOWN,
 network_reset = ENETRESET,
 network_unreachable = ENETUNREACH,
 no_buffer_space = ENOBUFS,
 no_child_process = ECHILD,
 no_link = ENOLINK,
 no_lock_available = ENOLCK,
#ifdef ENODATA
 no_message_available = ENODATA,
#else
 no_message_available = ENOMSG,
#endif
 no_message = ENOMSG,
 no_protocol_option = ENOPROTOOPT,
 no_space_on_device = ENOSPC,
#ifdef ENOSR
 no_stream_resources = ENOSR,
#else
 no_stream_resources = ENOMEM,
#endif
 no_such_device_or_address = ENXIO,
 no_such_device = ENODEV,
 no_such_file_or_directory = ENOENT,
 no_such_process = ESRCH,
 not_a_directory = ENOTDIR,
 not_a_socket = ENOTSOCK,
#ifdef ENOSTR
 not_a_stream = ENOSTR,
#else
 not_a_stream = EINVAL,
#endif
 not_connected = ENOTCONN,
 not_enough_memory = ENOMEM,
 not_supported = ENOTSUP,
 operation_canceled = ECANCELED,
 operation_in_progress = EINPROGRESS,
 operation_not_permitted = EPERM,
 operation_not_supported = EOPNOTSUPP,
 operation_would_block = EWOULDBLOCK,
 owner_dead = EOWNERDEAD,
 permission_denied = EACCES,
 protocol_error = EPROTO,
 protocol_not_supported = EPROTONOSUPPORT,
 read_only_file_system = EROFS,
 resource_deadlock_would_occur = EDEADLK,
 resource_unavailable_try_again = EAGAIN,
 result_out_of_range = ERANGE,
 state_not_recoverable = ENOTRECOVERABLE,
#ifdef ETIME
 stream_timeout = ETIME,
#else
 stream_timeout = ETIMEDOUT,
#endif
 text_file_busy = ETXTBSY,
 timed_out = ETIMEDOUT,
 too_many_files_open_in_system = ENFILE,
 too_many_files_open = EMFILE,
 too_many_links = EMLINK,
 too_many_symbolic_link_levels = ELOOP,
 value_too_large = EOVERFLOW,
 wrong_protocol_type = EPROTOTYPE
};
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)

template <>
struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc>
 : true_type { };

#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
template <>
struct _LIBCPP_TYPE_VIS_ONLY 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;

#ifdef _LIBCPP_BUILDING_SYSTEM_ERROR
 error_category() _NOEXCEPT;
#else
 _LIBCPP_ALWAYS_INLINE
 _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_ALWAYS_INLINE
 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}

 _LIBCPP_ALWAYS_INLINE
 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}

 _LIBCPP_ALWAYS_INLINE
 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_ALWAYS_INLINE
 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}

 _LIBCPP_ALWAYS_INLINE
 error_condition(int __val, const error_category& __cat) _NOEXCEPT
 : __val_(__val), __cat_(&__cat) {}

 template <class _Ep>
 _LIBCPP_ALWAYS_INLINE
 error_condition(_Ep __e,
 typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
 ) _NOEXCEPT
 {*this = make_error_condition(__e);}

 _LIBCPP_ALWAYS_INLINE
 void assign(int __val, const error_category& __cat) _NOEXCEPT
 {
 __val_ = __val;
 __cat_ = &__cat;
 }

 template <class _Ep>
 _LIBCPP_ALWAYS_INLINE
 typename enable_if
 <
 is_error_condition_enum<_Ep>::value,
 error_condition&
 >::type
 operator=(_Ep __e) _NOEXCEPT
 {*this = make_error_condition(__e); return *this;}

 _LIBCPP_ALWAYS_INLINE
 void clear() _NOEXCEPT
 {
 __val_ = 0;
 __cat_ = &generic_category();
 }

 _LIBCPP_ALWAYS_INLINE
 int value() const _NOEXCEPT {return __val_;}

 _LIBCPP_ALWAYS_INLINE
 const error_category& category() const _NOEXCEPT {return *__cat_;}
 string message() const;

 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_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_ALWAYS_INLINE
 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}

 _LIBCPP_ALWAYS_INLINE
 error_code(int __val, const error_category& __cat) _NOEXCEPT
 : __val_(__val), __cat_(&__cat) {}

 template <class _Ep>
 _LIBCPP_ALWAYS_INLINE
 error_code(_Ep __e,
 typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
 ) _NOEXCEPT
 {*this = make_error_code(__e);}

 _LIBCPP_ALWAYS_INLINE
 void assign(int __val, const error_category& __cat) _NOEXCEPT
 {
 __val_ = __val;
 __cat_ = &__cat;
 }

 template <class _Ep>
 _LIBCPP_ALWAYS_INLINE
 typename enable_if
 <
 is_error_code_enum<_Ep>::value,
 error_code&
 >::type
 operator=(_Ep __e) _NOEXCEPT
 {*this = make_error_code(__e); return *this;}

 _LIBCPP_ALWAYS_INLINE
 void clear() _NOEXCEPT
 {
 __val_ = 0;
 __cat_ = &system_category();
 }

 _LIBCPP_ALWAYS_INLINE
 int value() const _NOEXCEPT {return __val_;}

 _LIBCPP_ALWAYS_INLINE
 const error_category& category() const _NOEXCEPT {return *__cat_;}

 _LIBCPP_ALWAYS_INLINE
 error_condition default_error_condition() const _NOEXCEPT
 {return __cat_->default_error_condition(__val_);}

 string message() const;

 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_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_TYPE_VIS_ONLY 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());
 }
};

// 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() _NOEXCEPT;

 _LIBCPP_ALWAYS_INLINE
 const error_code& code() const _NOEXCEPT {return __ec_;}

private:
 static string __init(const error_code&, string);
};

_LIBCPP_FUNC_VIS void __throw_system_error(int ev, const char* what_arg);

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP_SYSTEM_ERROR