system_error File Reference

#include <cerrno>
#include <cstdlib>
#include <stdexcept>

Classes
struct	is_error_code_enum< _Enum >
struct	is_error_code_enum< _Io_errc >
struct	is_error_condition_enum< _Enum >
struct	is_error_condition_enum< _Errc >
class	error_category
class	error_code
class	error_condition
struct	hash< error_code >
class	_System_error
class	system_error
class	_Generic_error_category
class	_Iostream_error_category
class	_System_error_category
struct	_Immortalizer< _Ty >

Macros
#define	_SYSTEM_ERROR_

Typedefs
typedef errc	_Errc
typedef io_errc	_Io_errc

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

Functions
error_code	make_error_code (_Errc) _NOEXCEPT
error_code	make_error_code (_Io_errc) _NOEXCEPT
error_condition	make_error_condition (_Errc) _NOEXCEPT
error_condition	make_error_condition (_Io_errc) _NOEXCEPT
const error_category &	generic_category () _NOEXCEPT
const error_category &	iostream_category () _NOEXCEPT
const error_category &	system_category () _NOEXCEPT
bool	operator== (const error_code &_Left, const error_code &_Right) _NOEXCEPT
bool	operator== (const error_code &_Left, const error_condition &_Right) _NOEXCEPT
bool	operator== (const error_condition &_Left, const error_code &_Right) _NOEXCEPT
bool	operator== (const error_condition &_Left, const error_condition &_Right) _NOEXCEPT
bool	operator!= (const error_code &_Left, const error_code &_Right) _NOEXCEPT
bool	operator!= (const error_code &_Left, const error_condition &_Right) _NOEXCEPT
bool	operator!= (const error_condition &_Left, const error_code &_Right) _NOEXCEPT
bool	operator!= (const error_condition &_Left, const error_condition &_Right) _NOEXCEPT
bool	operator< (const error_code &_Left, const error_code &_Right) _NOEXCEPT
bool	operator< (const error_condition &_Left, const error_condition &_Right) _NOEXCEPT
_CRTIMP2_PURE const char *__CLRCALL_PURE_OR_CDECL	_Syserror_map (int)
_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL	_Winerror_map (int)
_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL	_Winerror_message (unsigned long _Message_id, char *_Narrow, unsigned long _Size)
template<class _Ty >
_Ty &	_Immortalize ()

Macro Definition Documentation

#define _SYSTEM_ERROR_

Typedef Documentation

typedef errc _Errc

typedef io_errc _Io_errc

Enumeration Type Documentation

enum errc

strong

Enumerator
address_family_not_supported
address_in_use
address_not_available
already_connected
argument_list_too_long
argument_out_of_domain
bad_address
bad_file_descriptor
bad_message
broken_pipe
connection_aborted
connection_already_in_progress
connection_refused
connection_reset
cross_device_link
destination_address_required
device_or_resource_busy
directory_not_empty
executable_format_error
file_exists
file_too_large
filename_too_long
function_not_supported
host_unreachable
identifier_removed
illegal_byte_sequence
inappropriate_io_control_operation
interrupted
invalid_argument
invalid_seek
io_error
is_a_directory
message_size
network_down
network_reset
network_unreachable
no_buffer_space
no_child_process
no_link
no_lock_available
no_message_available
no_message
no_protocol_option
no_space_on_device
no_stream_resources
no_such_device_or_address
no_such_device
no_such_file_or_directory
no_such_process
not_a_directory
not_a_socket
not_a_stream
not_connected
not_enough_memory
not_supported
operation_canceled
operation_in_progress
operation_not_permitted
operation_not_supported
operation_would_block
owner_dead
permission_denied
protocol_error
protocol_not_supported
read_only_file_system
resource_deadlock_would_occur
resource_unavailable_try_again
result_out_of_range
state_not_recoverable
stream_timeout
text_file_busy
timed_out
too_many_files_open_in_system
too_many_files_open
too_many_links
too_many_symbolic_link_levels
value_too_large
wrong_protocol_type

                {   // names for generic error codes
    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
    };

enum io_errc

strong

Enumerator
stream

                   {    // error codes for ios_base::failure
    stream = 1
    };

Function Documentation

template<class _Ty >

_Ty& _Immortalize ( )

inline

    {   // return a reference to an object that will live forever
    /* MAGIC */ static _Immortalizer<_Ty> _Static;
    return (*reinterpret_cast<_Ty *>(&_Static._Storage));
    }

_CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map

(

int

)

_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map

(

int

)

_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Winerror_message	(	unsigned long	_Message_id,
		char *	_Narrow,
		unsigned long	_Size
	)

const error_category & generic_category ( )

inline

    {   // get generic_category
    return (_Immortalize<_Generic_error_category>());
    }

const error_category & iostream_category ( )

inline

    {   // get iostream_category
    return (_Immortalize<_Iostream_error_category>());
    }

error_code make_error_code ( _Errc  _Errno )

inline

    {   // make an error_code
    return (error_code((int)_Errno, generic_category()));
    }

error_code make_error_code ( _Io_errc  _Errno )

inline

    {   // make an error_code
    return (error_code((int)_Errno, iostream_category()));
    }

error_condition make_error_condition ( _Errc  _Errno )

inline

    {   // make an error_condition
    return (error_condition((int)_Errno, generic_category()));
    }

error_condition make_error_condition ( _Io_errc  _Errno )

inline

    {   // make an error_condition
    return (error_condition((int)_Errno, iostream_category()));
    }

bool operator!= ( const error_code &  _Left, const error_code &  _Right  )

inline

    {   // test errors for inequality
    return (!(_Left == _Right));
    }

bool operator!= ( const error_code &  _Left, const error_condition &  _Right  )

inline

    {   // test errors for inequality
    return (!(_Left == _Right));
    }

bool operator!= ( const error_condition &  _Left, const error_code &  _Right  )

inline

    {   // test errors for inequality
    return (!(_Left == _Right));
    }

bool operator!= ( const error_condition &  _Left, const error_condition &  _Right  )

inline

    {   // test errors for inequality
    return (!(_Left == _Right));
    }

bool operator< ( const error_code &  _Left, const error_code &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.category() < _Right.category()
        || (_Left.category() == _Right.category()
            && _Left.value() < _Right.value()));
    }

bool operator< ( const error_condition &  _Left, const error_condition &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.category() < _Right.category()
        || (_Left.category() == _Right.category()
            && _Left.value() < _Right.value()));
    }

bool operator== ( const error_code &  _Left, const error_code &  _Right  )

inline

    {   // test errors for equality
    return (_Left.category() == _Right.category()
        && _Left.value() == _Right.value());
    }

bool operator== ( const error_code &  _Left, const error_condition &  _Right  )

inline

    {   // test errors for equality
    return (_Left.category().equivalent(_Left.value(), _Right)
        || _Right.category().equivalent(_Left, _Right.value()));
    }

bool operator== ( const error_condition &  _Left, const error_code &  _Right  )

inline

    {   // test errors for equality
    return (_Right.category().equivalent(_Right.value(), _Left)
        || _Left.category().equivalent(_Right, _Left.value()));
    }

bool operator== ( const error_condition &  _Left, const error_condition &  _Right  )

inline

    {   // test errors for equality
    return (_Left.category() == _Right.category()
        && _Left.value() == _Right.value());
    }

const error_category & system_category ( )

inline

    {   // get system_category
    return (_Immortalize<_System_error_category>());
    }