x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
error_code.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\system\error_code.hpp
旋转
特效
属性
历史版本
// boost/system/error_code.hpp ---------------------------------------------// // Copyright Beman Dawes 2006, 2007 // Copyright Christoper Kohlhoff 2007 // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See library home page at http://www.boost.org/libs/system #ifndef BOOST_ERROR_CODE_HPP #define BOOST_ERROR_CODE_HPP #include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// TODO: undef these macros if not already defined #include
#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API) # error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined #endif #include
// must be the last #include namespace boost { namespace system { class error_code; class error_condition; // "Concept" helpers ---------------------------------------------------// template< class T > struct is_error_code_enum { static const bool value = false; }; template< class T > struct is_error_condition_enum { static const bool value = false; }; // portable error_conditions -------------------------------------------// namespace posix_error { enum posix_errno { success = 0, 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_synbolic_link_levels = ELOOP, value_too_large = EOVERFLOW, wrong_protocol_type = EPROTOTYPE }; } // namespace posix_error # ifndef BOOST_SYSTEM_NO_DEPRECATED namespace posix = posix_error; # endif template<> struct is_error_condition_enum
{ static const bool value = true; }; // ----------------------------------------------------------------------// // Operating system specific interfaces --------------------------------// // The interface is divided into general and system-specific portions to // meet these requirements: // // * Code calling an operating system API can create an error_code with // a single category (system_category), even for POSIX-like operating // systems that return some POSIX errno values and some native errno // values. This code should not have to pay the cost of distinguishing // between categories, since it is not yet known if that is needed. // // * Users wishing to write system-specific code should be given enums for // at least the common error cases. // // * System specific code should fail at compile time if moved to another // operating system. // The system specific portions of the interface are located in headers // with names reflecting the operating system. For example, // //
//
//
// // These headers are effectively empty for compiles on operating systems // where they are not applicable. // ----------------------------------------------------------------------// // class error_category ------------------------------------------------// class error_category : public noncopyable { public: virtual ~error_category(){} virtual inline const char * name() const; // see implementation note below virtual inline std::string message( int ev ) const; // see implementation note below virtual inline error_condition default_error_condition( int ev ) const; virtual inline bool equivalent( int code, const error_condition & condition ) const; virtual inline bool equivalent( const error_code & code, int condition ) const; bool operator==(const error_category & rhs) const { return this == &rhs; } bool operator!=(const error_category & rhs) const { return this != &rhs; } bool operator<( const error_category & rhs ) const { return std::less
()( this, &rhs ); } }; // predefined error categories -----------------------------------------// BOOST_SYSTEM_DECL const error_category & get_system_category(); BOOST_SYSTEM_DECL const error_category & get_posix_category(); static const error_category & system_category = get_system_category(); static const error_category & posix_category = get_posix_category(); # ifndef BOOST_SYSTEM_NO_DEPRECATED // deprecated synonyms static const error_category & errno_ecat = get_posix_category(); static const error_category & native_ecat = get_system_category(); # endif // class error_condition -----------------------------------------------// // error_conditions are portable, error_codes are system or lib specific class error_condition { public: // constructors: error_condition() : m_val(0), m_cat(&get_posix_category()) {} error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {} template
error_condition(ConditionEnum e, typename boost::enable_if
>::type* = 0) { *this = make_error_condition(e); } // modifiers: void assign( int val, const error_category & cat ) { m_val = val; m_cat = &cat; } template
typename boost::enable_if
, error_condition>::type & operator=( ConditionEnum val ) { *this = make_error_condition(val); return *this; } void clear() { m_val = 0; m_cat = &get_posix_category(); } // observers: int value() const { return m_val; } const error_category & category() const { return *m_cat; } std::string message() const { return m_cat->message(value()); } typedef void (*unspecified_bool_type)(); static void unspecified_bool_true() {} operator unspecified_bool_type() const // true if error { return m_val == 0 ? 0 : unspecified_bool_true; } bool operator!() const // true if no error { return m_val == 0; } // relationals: // the more symmetrical non-member syntax allows enum // conversions work for both rhs and lhs. inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) { return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val; } inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) // the more symmetrical non-member syntax allows enum // conversions work for both rhs and lhs. { return lhs.m_cat < rhs.m_cat || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val); } private: int m_val; const error_category * m_cat; }; // class error_code ----------------------------------------------------// // We want error_code to be a value type that can be copied without slicing // and without requiring heap allocation, but we also want it to have // polymorphic behavior based on the error category. This is achieved by // abstract base class error_category supplying the polymorphic behavior, // and error_code containing a pointer to an object of a type derived // from error_category. class error_code { public: // constructors: error_code() : m_val(0), m_cat(&get_system_category()) {} error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {} template
error_code(CodeEnum e, typename boost::enable_if
>::type* = 0) { *this = make_error_code(e); } // modifiers: void assign( int val, const error_category & cat ) { m_val = val; m_cat = &cat; } template
typename boost::enable_if
, error_code>::type & operator=( CodeEnum val ) { *this = make_error_code(val); return *this; } void clear() { m_val = 0; m_cat = &get_system_category(); } // observers: int value() const { return m_val; } const error_category & category() const { return *m_cat; } error_condition default_error_condition() const { return m_cat->default_error_condition(value()); } std::string message() const { return m_cat->message(value()); } typedef void (*unspecified_bool_type)(); static void unspecified_bool_true() {} operator unspecified_bool_type() const // true if error { return m_val == 0 ? 0 : unspecified_bool_true; } bool operator!() const // true if no error { return m_val == 0; } // relationals: inline friend bool operator==( const error_code & lhs, const error_code & rhs ) // the more symmetrical non-member syntax allows enum // conversions work for both rhs and lhs. { return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val; } inline friend bool operator<( const error_code & lhs, const error_code & rhs ) // the more symmetrical non-member syntax allows enum // conversions work for both rhs and lhs. { return lhs.m_cat < rhs.m_cat || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val); } private: int m_val; const error_category * m_cat; }; // non-member functions ------------------------------------------------// inline bool operator!=( const error_code & lhs, const error_code & rhs ) { return !(lhs == rhs); } inline bool operator!=( const error_condition & lhs, const error_condition & rhs ) { return !(lhs == rhs); } inline bool operator==( const error_code & code, const error_condition & condition ) { return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() ); } inline bool operator!=( const error_code & lhs, const error_condition & rhs ) { return !(lhs == rhs); } inline bool operator==( const error_condition & condition, const error_code & code ) { return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition ); } inline bool operator!=( const error_condition & lhs, const error_code & rhs ) { return !(lhs == rhs); } // TODO: both of these may move elsewhere, but the LWG hasn't spoken yet. template
inline std::basic_ostream
& operator<< (std::basic_ostream
& os, error_code ec) { os << ec.category().name() << ':' << ec.value(); return os; } inline std::size_t hash_value( const error_code & ec ) { return static_cast
(ec.value()) + reinterpret_cast
(&ec.category()); } // make_* functions for posix_error::posix_errno -----------------------------// namespace posix_error { // explicit conversion: inline error_code make_error_code( posix_errno e ) { return error_code( e, get_posix_category() ); } // implicit conversion: inline error_condition make_error_condition( posix_errno e ) { return error_condition( e, get_posix_category() ); } } // error_category default implementation -------------------------------// inline error_condition error_category::default_error_condition( int ev ) const { return error_condition( ev, *this ); } inline bool error_category::equivalent( int code, const error_condition & condition ) const { return default_error_condition( code ) == condition; } inline bool error_category::equivalent( const error_code & code, int condition ) const { return *this == code.category() && code.value() == condition; } // error_category implementation note: VC++ 8.0 objects to name() and // message() being pure virtual functions. Thus these implementations. inline const char * error_category::name() const { return "error: should never be called"; } inline std::string error_category::message( int ) const { static std::string s("error: should never be called"); return s; } } // namespace system } // namespace boost #include
// pops abi_prefix.hpp pragmas # ifdef BOOST_ERROR_CODE_HEADER_ONLY # include
# endif #endif // BOOST_ERROR_CODE_HPP
error_code.hpp
网页地址
文件地址
上一页
3/6
下一页
下载
( 16 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.