summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2009-06-01 08:48:42 (GMT)
committerRemko Tronçon <git@el-tramo.be>2009-06-01 09:24:28 (GMT)
commit2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
treed46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/system
downloadswift-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
Import.
Diffstat (limited to '3rdParty/Boost/boost/system')
-rw-r--r--3rdParty/Boost/boost/system/config.hpp75
-rw-r--r--3rdParty/Boost/boost/system/error_code.hpp501
-rw-r--r--3rdParty/Boost/boost/system/system_error.hpp81
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
+
+