Swiftdiff options
Diffstat (limited to '3rdParty/Boost/boost/system')
| -rw-r--r-- | 3rdParty/Boost/boost/system/config.hpp | 75 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/system/error_code.hpp | 501 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/system/system_error.hpp | 81 |
3 files changed, 657 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/system/config.hpp b/3rdParty/Boost/boost/system/config.hpp new file mode 100644 index 0000000..fa09099 --- /dev/null +++ b/3rdParty/Boost/boost/system/config.hpp @@ -0,0 +1,75 @@ +// boost/system/config.hpp -------------------------------------------------// + +// Copyright Beman Dawes 2003, 2006 + +// 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 http://www.boost.org/libs/system for documentation. + +#ifndef BOOST_SYSTEM_CONFIG_HPP +#define BOOST_SYSTEM_CONFIG_HPP + +#include <boost/config.hpp> + +// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use. +// If not specified, a sensible default will be applied. + +# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API ) +# error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined +# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API ) +# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__) +# define BOOST_WINDOWS_API +# else +# define BOOST_POSIX_API +# endif +# endif + +// enable dynamic linking on Windows ---------------------------------------// + +//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__) +//# error Dynamic linking Boost.System does not work for Borland; use static linking instead +//# endif + +#ifdef BOOST_HAS_DECLSPEC // defined in config system +// we need to import/export our code only if the user has specifically +// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost +// libraries to be dynamically linked, or BOOST_SYSTEM_DYN_LINK +// if they want just this one to be dynamically liked: +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK) +// export if this is our own source, otherwise import: +#ifdef BOOST_SYSTEM_SOURCE +# define BOOST_SYSTEM_DECL __declspec(dllexport) +#else +# define BOOST_SYSTEM_DECL __declspec(dllimport) +#endif // BOOST_SYSTEM_SOURCE +#endif // DYN_LINK +#endif // BOOST_HAS_DECLSPEC +// +// if BOOST_SYSTEM_DECL isn't defined yet define it now: +#ifndef BOOST_SYSTEM_DECL +#define BOOST_SYSTEM_DECL +#endif + +// enable automatic library variant selection ------------------------------// + +#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB) +// +// Set the name of our library, this will get undef'ed by auto_link.hpp +// once it's done with it: +// +#define BOOST_LIB_NAME boost_system +// +// If we're importing code from a dll, then tell auto_link.hpp about it: +// +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK) +# define BOOST_DYN_LINK +#endif +// +// And include the header that does the work: +// +#include <boost/config/auto_link.hpp> +#endif // auto-linking disabled + +#endif // BOOST_SYSTEM_CONFIG_HPP + diff --git a/3rdParty/Boost/boost/system/error_code.hpp b/3rdParty/Boost/boost/system/error_code.hpp new file mode 100644 index 0000000..8f795d7 --- /dev/null +++ b/3rdParty/Boost/boost/system/error_code.hpp @@ -0,0 +1,501 @@ +// 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 <boost/system/config.hpp> +#include <boost/cstdint.hpp> +#include <boost/assert.hpp> +#include <boost/operators.hpp> +#include <boost/noncopyable.hpp> +#include <boost/utility/enable_if.hpp> +#include <ostream> +#include <string> +#include <stdexcept> +#include <functional> + +// TODO: undef these macros if not already defined +#include <boost/cerrno.hpp> + +#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API) +# error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined +#endif + +#include <boost/config/abi_prefix.hpp> // 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; }; + + // generic error_conditions --------------------------------------------// + + namespace errc + { + enum errc_t + { + 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 errc + +# ifndef BOOST_SYSTEM_NO_DEPRECATED + namespace posix = errc; + namespace posix_error = errc; +# endif + + template<> struct is_error_condition_enum<errc::errc_t> + { 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, + // + // <boost/system/cygwin_error.hpp> + // <boost/system/linux_error.hpp> + // <boost/system/windows_error.hpp> + // + // 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<const error_category*>()( this, &rhs ); + } + }; + + // predefined error categories -----------------------------------------// + + BOOST_SYSTEM_DECL const error_category & get_system_category(); + BOOST_SYSTEM_DECL const error_category & get_generic_category(); + + static const error_category & system_category = get_system_category(); + static const error_category & generic_category = get_generic_category(); + +# ifndef BOOST_SYSTEM_NO_DEPRECATED + // deprecated synonyms + inline const error_category & get_posix_category() { return get_generic_category(); } + static const error_category & posix_category = get_generic_category(); + static const error_category & errno_ecat = get_generic_category(); + static const error_category & native_ecat = get_system_category(); +# endif + + // class error_condition -----------------------------------------------// + + // error_conditions are portable, error_codes are system or library specific + + class error_condition + { + public: + + // constructors: + error_condition() : m_val(0), m_cat(&get_generic_category()) {} + error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {} + + template <class ErrorConditionEnum> + error_condition(ErrorConditionEnum e, + typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) + { + *this = make_error_condition(e); + } + + // modifiers: + + void assign( int val, const error_category & cat ) + { + m_val = val; + m_cat = &cat; + } + + template<typename ErrorConditionEnum> + typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type & + operator=( ErrorConditionEnum val ) + { + *this = make_error_condition(val); + return *this; + } + + void clear() + { + m_val = 0; + m_cat = &get_generic_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 <class ErrorCodeEnum> + error_code(ErrorCodeEnum e, + typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) + { + *this = make_error_code(e); + } + + // modifiers: + void assign( int val, const error_category & cat ) + { + m_val = val; + m_cat = &cat; + } + + template<typename ErrorCodeEnum> + typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type & + operator=( ErrorCodeEnum 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; + + }; + + // predefined error_code object used as "throw on error" tag + BOOST_SYSTEM_DECL extern error_code throws; + + // 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 <class charT, class traits> + inline std::basic_ostream<charT,traits>& + operator<< (std::basic_ostream<charT,traits>& 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<std::size_t>(ec.value()) + + reinterpret_cast<std::size_t>(&ec.category()); + } + + // make_* functions for errc::errc_t -----------------------------// + + namespace errc + { + // explicit conversion: + inline error_code make_error_code( errc_t e ) + { return error_code( e, get_generic_category() ); } + + // implicit conversion: + inline error_condition make_error_condition( errc_t e ) + { return error_condition( e, get_generic_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 <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas + +# ifdef BOOST_ERROR_CODE_HEADER_ONLY +# include <boost/../libs/system/src/error_code.cpp> +# endif + +#endif // BOOST_ERROR_CODE_HPP + + diff --git a/3rdParty/Boost/boost/system/system_error.hpp b/3rdParty/Boost/boost/system/system_error.hpp new file mode 100644 index 0000000..4091647 --- /dev/null +++ b/3rdParty/Boost/boost/system/system_error.hpp @@ -0,0 +1,81 @@ +// Boost system_error.hpp --------------------------------------------------// + +// Copyright Beman Dawes 2006 + +// 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) + +#ifndef BOOST_SYSTEM_ERROR_HPP +#define BOOST_SYSTEM_ERROR_HPP + +#include <string> +#include <stdexcept> +#include <cassert> +#include <boost/system/error_code.hpp> + +namespace boost +{ + namespace system + { + // class system_error --------------------------------------------------// + + class system_error : public std::runtime_error + { + public: + system_error( error_code ec ) + : std::runtime_error(""), m_error_code(ec) {} + + system_error( error_code ec, const std::string & what_arg ) + : std::runtime_error(what_arg), m_error_code(ec) {} + + system_error( error_code ec, const char* what_arg ) + : std::runtime_error(what_arg), m_error_code(ec) {} + + system_error( int ev, const error_category & ecat ) + : std::runtime_error(""), m_error_code(ev,ecat) {} + + system_error( int ev, const error_category & ecat, + const std::string & what_arg ) + : std::runtime_error(what_arg), m_error_code(ev,ecat) {} + + system_error( int ev, const error_category & ecat, + const char * what_arg ) + : std::runtime_error(what_arg), m_error_code(ev,ecat) {} + + virtual ~system_error() throw() {} + + const error_code & code() const throw() { return m_error_code; } + const char * what() const throw(); + + private: + error_code m_error_code; + mutable std::string m_what; + }; + + // implementation ------------------------------------------------------// + + inline const char * system_error::what() const throw() + // see http://www.boost.org/more/error_handling.html for lazy build rationale + { + if ( m_what.empty() ) + { + try + { + m_what = this->std::runtime_error::what(); + if ( m_error_code ) + { + if ( !m_what.empty() ) m_what += ": "; + m_what += m_error_code.message(); + } + } + catch (...) { return std::runtime_error::what(); } + } + return m_what.c_str(); + } + + } // namespace system +} // namespace boost + +#endif // BOOST_SYSTEM_ERROR_HPP + + |