Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/asio/detail')
228 files changed, 8133 insertions, 2133 deletions
diff --git a/3rdParty/Boost/src/boost/asio/detail/addressof.hpp b/3rdParty/Boost/src/boost/asio/detail/addressof.hpp new file mode 100644 index 0000000..7b47331 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/addressof.hpp @@ -0,0 +1,40 @@ +// +// detail/addressof.hpp +// ~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_ADDRESSOF_HPP +#define BOOST_ASIO_DETAIL_ADDRESSOF_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_ADDRESSOF) +# include <memory> +#else // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) +# include <boost/utility/addressof.hpp> +#endif // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) + +namespace boost { +namespace asio { +namespace detail { + +#if defined(BOOST_ASIO_HAS_STD_ADDRESSOF) +using std::addressof; +#else // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) +using boost::addressof; +#endif // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) + +} // namespace detail +} // namespace asio +} // namespace boost + +#endif // BOOST_ASIO_DETAIL_ADDRESSOF_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/array.hpp b/3rdParty/Boost/src/boost/asio/detail/array.hpp index be141b1..8909e24 100644 --- a/3rdParty/Boost/src/boost/asio/detail/array.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/array.hpp @@ -1,11 +1,11 @@ // // detail/array.hpp // ~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_ARRAY_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp index f97ed0b..219f45c 100644 --- a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp @@ -1,11 +1,11 @@ // // detail/array_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_ARRAY_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/assert.hpp b/3rdParty/Boost/src/boost/asio/detail/assert.hpp new file mode 100644 index 0000000..b4498d1 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/assert.hpp @@ -0,0 +1,32 @@ +// +// detail/assert.hpp +// ~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_ASSERT_HPP +#define BOOST_ASIO_DETAIL_ASSERT_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_BOOST_ASSERT) +# include <boost/assert.hpp> +#else // defined(BOOST_ASIO_HAS_BOOST_ASSERT) +# include <cassert> +#endif // defined(BOOST_ASIO_HAS_BOOST_ASSERT) + +#if defined(BOOST_ASIO_HAS_BOOST_ASSERT) +# define BOOST_ASIO_ASSERT(expr) BOOST_ASSERT(expr) +#else // defined(BOOST_ASIO_HAS_BOOST_ASSERT) +# define BOOST_ASIO_ASSERT(expr) assert(expr) +#endif // defined(BOOST_ASIO_HAS_BOOST_ASSERT) + +#endif // BOOST_ASIO_DETAIL_ASSERT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp index 5e0051a..c39e926 100644 --- a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp @@ -1,11 +1,11 @@ // // detail/atomic_count.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_ATOMIC_COUNT_HPP @@ -14,25 +14,25 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) // Nothing to include. #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) # include <atomic> #else // defined(BOOST_ASIO_HAS_STD_ATOMIC) # include <boost/detail/atomic_count.hpp> #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC) namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) typedef long atomic_count; inline void increment(atomic_count& a, long b) { a += b; } #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) typedef std::atomic<long> atomic_count; inline void increment(atomic_count& a, long b) { a += b; } #else // defined(BOOST_ASIO_HAS_STD_ATOMIC) diff --git a/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp b/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp index 635b9c1..07e24f0 100644 --- a/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp @@ -1,11 +1,11 @@ // // detail/base_from_completion_cond.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp index 0bd7e53..e8f488d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp @@ -1,11 +1,11 @@ // // detail/bind_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_BIND_HANDLER_HPP @@ -14,12 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { @@ -69,12 +70,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, binder1<Handler, Arg1>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } +template <typename Handler, typename Arg1> +inline bool asio_handler_is_continuation( + binder1<Handler, Arg1>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + template <typename Function, typename Handler, typename Arg1> inline void asio_handler_invoke(Function& function, binder1<Handler, Arg1>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); @@ -143,12 +152,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } +template <typename Handler, typename Arg1, typename Arg2> +inline bool asio_handler_is_continuation( + binder2<Handler, Arg1, Arg2>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + template <typename Function, typename Handler, typename Arg1, typename Arg2> inline void asio_handler_invoke(Function& function, binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); @@ -223,12 +240,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } +template <typename Handler, typename Arg1, typename Arg2, typename Arg3> +inline bool asio_handler_is_continuation( + binder3<Handler, Arg1, Arg2, Arg3>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3> inline void asio_handler_invoke(Function& function, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { boost_asio_handler_invoke_helpers::invoke( @@ -312,12 +337,21 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } +template <typename Handler, typename Arg1, typename Arg2, typename Arg3, + typename Arg4> +inline bool asio_handler_is_continuation( + binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline void asio_handler_invoke(Function& function, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { boost_asio_handler_invoke_helpers::invoke( @@ -408,12 +442,21 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } +template <typename Handler, typename Arg1, typename Arg2, typename Arg3, + typename Arg4, typename Arg5> +inline bool asio_handler_is_continuation( + binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline void asio_handler_invoke(Function& function, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { boost_asio_handler_invoke_helpers::invoke( diff --git a/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp b/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp index ea78330..56304e5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp @@ -1,11 +1,11 @@ // // detail/buffer_resize_guard.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/limits.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -36,24 +36,22 @@ public: { } // Destructor rolls back the buffer resize unless commit was called. ~buffer_resize_guard() { - if (old_size_ - != std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION()) + if (old_size_ != (std::numeric_limits<size_t>::max)()) { buffer_.resize(old_size_); } } // Commit the resize transaction. void commit() { - old_size_ - = std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION(); + old_size_ = (std::numeric_limits<size_t>::max)(); } private: // The buffer being managed. Buffer& buffer_; diff --git a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp index 562aa55..da81cbe 100644 --- a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp @@ -1,11 +1,11 @@ // // detail/buffer_sequence_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP @@ -26,13 +26,29 @@ namespace boost { namespace asio { namespace detail { class buffer_sequence_adapter_base { protected: -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + // The maximum number of buffers to support in a single operation. + enum { max_buffers = 1 }; + + typedef Windows::Storage::Streams::IBuffer^ native_buffer_type; + + BOOST_ASIO_DECL static void init_native_buffer( + native_buffer_type& buf, + const boost::asio::mutable_buffer& buffer); + + BOOST_ASIO_DECL static void init_native_buffer( + native_buffer_type& buf, + const boost::asio::const_buffer& buffer); +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) + // The maximum number of buffers to support in a single operation. + enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len }; + typedef WSABUF native_buffer_type; static void init_native_buffer(WSABUF& buf, const boost::asio::mutable_buffer& buffer) { buf.buf = boost::asio::buffer_cast<char*>(buffer); @@ -42,13 +58,16 @@ protected: static void init_native_buffer(WSABUF& buf, const boost::asio::const_buffer& buffer) { buf.buf = const_cast<char*>(boost::asio::buffer_cast<const char*>(buffer)); buf.len = static_cast<ULONG>(boost::asio::buffer_size(buffer)); } -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) + // The maximum number of buffers to support in a single operation. + enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len }; + typedef iovec native_buffer_type; static void init_iov_base(void*& base, void* addr) { base = addr; } @@ -70,13 +89,13 @@ protected: const boost::asio::const_buffer& buffer) { init_iov_base(iov.iov_base, const_cast<void*>( boost::asio::buffer_cast<const void*>(buffer))); iov.iov_len = boost::asio::buffer_size(buffer); } -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) }; // Helper class to translate buffers into the native buffer representation. template <typename Buffer, typename Buffers> class buffer_sequence_adapter : buffer_sequence_adapter_base @@ -143,15 +162,12 @@ public: return buffer; } return Buffer(); } private: - // The maximum number of buffers to support in a single operation. - enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len }; - native_buffer_type buffers_[max_buffers]; std::size_t count_; std::size_t total_buffer_size_; }; template <typename Buffer> @@ -359,7 +375,11 @@ private: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> +#if defined(BOOST_ASIO_HEADER_ONLY) +# include <boost/asio/detail/impl/buffer_sequence_adapter.ipp> +#endif // defined(BOOST_ASIO_HEADER_ONLY) + #endif // BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp index 3c7ba71..6f138d2 100644 --- a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp @@ -1,11 +1,11 @@ // // detail/buffered_stream_storage.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/asio/buffer.hpp> -#include <boost/assert.hpp> +#include <boost/asio/detail/assert.hpp> #include <cstddef> #include <cstring> #include <vector> #include <boost/asio/detail/push_options.hpp> @@ -76,13 +76,13 @@ public: return end_offset_ - begin_offset_; } // Resize the buffer to the specified length. void resize(size_type length) { - BOOST_ASSERT(length <= capacity()); + BOOST_ASIO_ASSERT(length <= capacity()); if (begin_offset_ + length <= capacity()) { end_offset_ = begin_offset_ + length; } else { @@ -99,13 +99,13 @@ public: return buffer_.size(); } // Consume multiple bytes from the beginning of the buffer. void consume(size_type count) { - BOOST_ASSERT(begin_offset_ + count <= end_offset_); + BOOST_ASIO_ASSERT(begin_offset_ + count <= end_offset_); begin_offset_ += count; if (empty()) clear(); } private: diff --git a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp index db4cd1e..62aeb40 100644 --- a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp @@ -1,11 +1,11 @@ // // detail/call_stack.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_CALL_STACK_HPP @@ -99,12 +99,19 @@ public: return elem->value_; elem = elem->next_; } return 0; } + // Obtain the value at the top of the stack. + static Value* top() + { + context* elem = top_; + return elem ? elem->value_ : 0; + } + private: // The top of the stack of calls for the current thread. static tss_ptr<context> top_; }; template <typename Key, typename Value> diff --git a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp b/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp index e56c8c3..6b81e5d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp @@ -1,31 +1,38 @@ // // detail/chrono_time_traits.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP #define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) -#include <boost/cstdint.hpp> +#include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { +// Helper template to compute the greatest common divisor. +template <int64_t v1, int64_t v2> +struct gcd { enum { value = gcd<v2, v1 % v2>::value }; }; + +template <int64_t v1> +struct gcd<v1, 0> { enum { value = v1 }; }; + // Adapts std::chrono clocks for use with a deadline timer. template <typename Clock, typename WaitTraits> struct chrono_time_traits { // The clock type. typedef Clock clock_type; @@ -45,19 +52,69 @@ struct chrono_time_traits return clock_type::now(); } // Add a duration to a time. static time_type add(const time_type& t, const duration_type& d) { + const time_type epoch; + if (t >= epoch) + { + if ((time_type::max)() - t < d) + return (time_type::max)(); + } + else // t < epoch + { + if (-(t - (time_type::min)()) > d) + return (time_type::min)(); + } + return t + d; } // Subtract one time from another. static duration_type subtract(const time_type& t1, const time_type& t2) { - return t1 - t2; + const time_type epoch; + if (t1 >= epoch) + { + if (t2 >= epoch) + { + return t1 - t2; + } + else if (t2 == (time_type::min)()) + { + return (duration_type::max)(); + } + else if ((time_type::max)() - t1 < epoch - t2) + { + return (duration_type::max)(); + } + else + { + return t1 - t2; + } + } + else // t1 < epoch + { + if (t2 < epoch) + { + return t1 - t2; + } + else if (t1 == (time_type::min)()) + { + return (duration_type::min)(); + } + else if ((time_type::max)() - t2 < epoch - t1) + { + return (duration_type::min)(); + } + else + { + return -(t2 - t1); + } + } } // Test whether one time is less than another. static bool less_than(const time_type& t1, const time_type& t2) { return t1 < t2; @@ -70,38 +127,44 @@ struct chrono_time_traits public: explicit posix_time_duration(const duration_type& d) : d_(d) { } - boost::int64_t ticks() const + int64_t ticks() const { return d_.count(); } - boost::int64_t total_seconds() const + int64_t total_seconds() const { return duration_cast<1, 1>(); } - boost::int64_t total_milliseconds() const + int64_t total_milliseconds() const { return duration_cast<1, 1000>(); } - boost::int64_t total_microseconds() const + int64_t total_microseconds() const { return duration_cast<1, 1000000>(); } private: - template <boost::int64_t Num, boost::int64_t Den> - boost::int64_t duration_cast() const + template <int64_t Num, int64_t Den> + int64_t duration_cast() const { - const boost::int64_t num = period_type::num * Den; - const boost::int64_t den = period_type::den * Num; + const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value; + const int64_t num2 = Num / gcd<period_type::num, Num>::value; + + const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value; + const int64_t den2 = Den / gcd<period_type::den, Den>::value; + + const int64_t num = num1 * den2; + const int64_t den = num2 * den1; if (num == 1 && den == 1) return ticks(); else if (num != 1 && den == 1) return ticks() * num; else if (num == 1 && period_type::den != 1) diff --git a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp index 19b4360..833f5a3 100644 --- a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp @@ -1,23 +1,24 @@ // // detail/completion_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_COMPLETION_HANDLER_HPP #define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/config.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -42,24 +43,24 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. completion_handler* h(static_cast<completion_handler*>(base)); - ptr p = { boost::addressof(h->handler_), h, h }; + ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(h->handler_)); - p.h = boost::addressof(handler); + p.h = boost::asio::detail::addressof(handler); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/config.hpp b/3rdParty/Boost/src/boost/asio/detail/config.hpp index c47c007..453f04d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/config.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/config.hpp @@ -1,72 +1,120 @@ // // detail/config.hpp // ~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_CONFIG_HPP #define BOOST_ASIO_DETAIL_CONFIG_HPP -#include <boost/config.hpp> -#include <boost/version.hpp> +#if defined(BOOST_ASIO_STANDALONE) +# define BOOST_ASIO_DISABLE_BOOST_ARRAY 1 +# define BOOST_ASIO_DISABLE_BOOST_ASSERT 1 +# define BOOST_ASIO_DISABLE_BOOST_BIND 1 +# define BOOST_ASIO_DISABLE_BOOST_CHRONO 1 +# define BOOST_ASIO_DISABLE_BOOST_DATE_TIME 1 +# define BOOST_ASIO_DISABLE_BOOST_LIMITS 1 +# define BOOST_ASIO_DISABLE_BOOST_REGEX 1 +# define BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT 1 +# define BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION 1 +# define BOOST_ASIO_DISABLE_BOOST_WORKAROUND 1 +#else // defined(BOOST_ASIO_STANDALONE) +# include <boost/config.hpp> +# include <boost/version.hpp> +# define BOOST_ASIO_HAS_BOOST_CONFIG 1 +#endif // defined(BOOST_ASIO_STANDALONE) // Default to a header-only implementation. The user must specifically request // separate compilation by defining either BOOST_ASIO_SEPARATE_COMPILATION or // BOOST_ASIO_DYN_LINK (as a DLL/shared library implies separate compilation). #if !defined(BOOST_ASIO_HEADER_ONLY) # if !defined(BOOST_ASIO_SEPARATE_COMPILATION) # if !defined(BOOST_ASIO_DYN_LINK) -# define BOOST_ASIO_HEADER_ONLY +# define BOOST_ASIO_HEADER_ONLY 1 # endif // !defined(BOOST_ASIO_DYN_LINK) # endif // !defined(BOOST_ASIO_SEPARATE_COMPILATION) #endif // !defined(BOOST_ASIO_HEADER_ONLY) #if defined(BOOST_ASIO_HEADER_ONLY) # define BOOST_ASIO_DECL inline #else // defined(BOOST_ASIO_HEADER_ONLY) -# if defined(BOOST_HAS_DECLSPEC) +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__) // We need to import/export our code only if the user has specifically asked // for it by defining BOOST_ASIO_DYN_LINK. # if defined(BOOST_ASIO_DYN_LINK) // Export if this is our own source, otherwise import. # if defined(BOOST_ASIO_SOURCE) # define BOOST_ASIO_DECL __declspec(dllexport) # else // defined(BOOST_ASIO_SOURCE) # define BOOST_ASIO_DECL __declspec(dllimport) # endif // defined(BOOST_ASIO_SOURCE) # endif // defined(BOOST_ASIO_DYN_LINK) -# endif // defined(BOOST_HAS_DECLSPEC) +# endif // defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__) #endif // defined(BOOST_ASIO_HEADER_ONLY) // If BOOST_ASIO_DECL isn't defined yet define it now. #if !defined(BOOST_ASIO_DECL) # define BOOST_ASIO_DECL #endif // !defined(BOOST_ASIO_DECL) +// Microsoft Visual C++ detection. +#if !defined(BOOST_ASIO_MSVC) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC) +# define BOOST_ASIO_MSVC BOOST_MSVC +# elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__) +# define BOOST_ASIO_MSVC _MSC_VER +# endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC) +#endif // defined(BOOST_ASIO_MSVC) + +// Clang / libc++ detection. +#if defined(__clang__) +# if (__cplusplus >= 201103) +# if __has_include(<__config>) +# include <__config> +# if defined(_LIBCPP_VERSION) +# define BOOST_ASIO_HAS_CLANG_LIBCXX 1 +# endif // defined(_LIBCPP_VERSION) +# endif // __has_include(<__config>) +# endif // (__cplusplus >= 201103) +#endif // defined(__clang__) + // Support move construction and assignment on compilers known to allow it. -#if !defined(BOOST_ASIO_DISABLE_MOVE) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_MOVE -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -#endif // !defined(BOOST_ASIO_DISABLE_MOVE) +#if !defined(BOOST_ASIO_HAS_MOVE) +# if !defined(BOOST_ASIO_DISABLE_MOVE) +# if defined(__clang__) +# if __has_feature(__cxx_rvalue_references__) +# define BOOST_ASIO_HAS_MOVE 1 +# endif // __has_feature(__cxx_rvalue_references__) +# endif // defined(__clang__) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_MOVE 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_MOVE 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_MOVE) +#endif // !defined(BOOST_ASIO_HAS_MOVE) // If BOOST_ASIO_MOVE_CAST isn't defined, and move support is available, define // BOOST_ASIO_MOVE_ARG and BOOST_ASIO_MOVE_CAST to take advantage of rvalue // references and perfect forwarding. #if defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST) # define BOOST_ASIO_MOVE_ARG(type) type&& # define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&> +# define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<type1, type2&&> #endif // defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST) // If BOOST_ASIO_MOVE_CAST still isn't defined, default to a C++03-compatible // implementation. Note that older g++ and MSVC versions don't like it when you // pass a non-member function through a const reference, so for most compilers // we'll play it safe and stick with the old approach of passing the handler by @@ -75,128 +123,361 @@ # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4) # define BOOST_ASIO_MOVE_ARG(type) const type& # else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4) # define BOOST_ASIO_MOVE_ARG(type) type # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4) -# elif defined(BOOST_MSVC) +# elif defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1400) # define BOOST_ASIO_MOVE_ARG(type) const type& # else // (_MSC_VER >= 1400) # define BOOST_ASIO_MOVE_ARG(type) type # endif // (_MSC_VER >= 1400) # else # define BOOST_ASIO_MOVE_ARG(type) type # endif # define BOOST_ASIO_MOVE_CAST(type) static_cast<const type&> -#endif // !defined_BOOST_ASIO_MOVE_CAST +# define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<const type1, type2&> +#endif // !defined(BOOST_ASIO_MOVE_CAST) // Support variadic templates on compilers known to allow it. -#if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_VARIADIC_TEMPLATES -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -#endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) +#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) +# if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) +# if defined(__clang__) +# if __has_feature(__cxx_variadic_templates__) +# define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1 +# endif // __has_feature(__cxx_variadic_templates__) +# endif // defined(__clang__) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) +#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) + +// Support constexpr on compilers known to allow it. +#if !defined(BOOST_ASIO_HAS_CONSTEXPR) +# if !defined(BOOST_ASIO_DISABLE_CONSTEXPR) +# if defined(__clang__) +# if __has_feature(__cxx_constexpr__) +# define BOOST_ASIO_HAS_CONSTEXPR 1 +# endif // __has_feature(__cxx_constexr__) +# endif // defined(__clang__) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_CONSTEXPR 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# endif // !defined(BOOST_ASIO_DISABLE_CONSTEXPR) +#endif // !defined(BOOST_ASIO_HAS_CONSTEXPR) +#if !defined(BOOST_ASIO_CONSTEXPR) +# if defined(BOOST_ASIO_HAS_CONSTEXPR) +# define BOOST_ASIO_CONSTEXPR constexpr +# else // defined(BOOST_ASIO_HAS_CONSTEXPR) +# define BOOST_ASIO_CONSTEXPR +# endif // defined(BOOST_ASIO_HAS_CONSTEXPR) +#endif // !defined(BOOST_ASIO_CONSTEXPR) // Standard library support for system errors. -#if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_STD_SYSTEM_ERROR -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -#endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) +# if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) // Compliant C++11 compilers put noexcept specifiers on error_category members. #if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) -# if defined(__GNUC__) +# if (BOOST_VERSION >= 105300) +# define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT +# elif defined(__clang__) +# if __has_feature(__cxx_noexcept__) +# define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true) +# endif // __has_feature(__cxx_noexcept__) +# elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) # if defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true) # endif // defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) # endif // defined(__GNUC__) # if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT # endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) #endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) // Standard library support for arrays. -#if !defined(BOOST_ASIO_DISABLE_STD_ARRAY) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_STD_ARRAY -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -# if defined(BOOST_MSVC) -# if (_MSC_VER >= 1600) -# define BOOST_ASIO_HAS_STD_ARRAY -# endif // (_MSC_VER >= 1600) -# endif // defined(BOOST_MSVC) -#endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY) +#if !defined(BOOST_ASIO_HAS_STD_ARRAY) +# if !defined(BOOST_ASIO_DISABLE_STD_ARRAY) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_ARRAY 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_ARRAY 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1600) +# define BOOST_ASIO_HAS_STD_ARRAY 1 +# endif // (_MSC_VER >= 1600) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY) +#endif // !defined(BOOST_ASIO_HAS_STD_ARRAY) // Standard library support for shared_ptr and weak_ptr. -#if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_STD_SHARED_PTR -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -# if defined(BOOST_MSVC) -# if (_MSC_VER >= 1600) -# define BOOST_ASIO_HAS_STD_SHARED_PTR -# endif // (_MSC_VER >= 1600) -# endif // defined(BOOST_MSVC) -#endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) +#if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) +# if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_SHARED_PTR 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_SHARED_PTR 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1600) +# define BOOST_ASIO_HAS_STD_SHARED_PTR 1 +# endif // (_MSC_VER >= 1600) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) +#endif // !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) // Standard library support for atomic operations. -#if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_STD_ATOMIC -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -#endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) +#if !defined(BOOST_ASIO_HAS_STD_ATOMIC) +# if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_ATOMIC 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_ATOMIC 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_ATOMIC 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) +#endif // !defined(BOOST_ASIO_HAS_STD_ATOMIC) // Standard library support for chrono. Some standard libraries (such as the // libstdc++ shipped with gcc 4.6) provide monotonic_clock as per early C++0x // drafts, rather than the eventually standardised name of steady_clock. -#if !defined(BOOST_ASIO_DISABLE_STD_CHRONO) -# if defined(__GNUC__) -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) -# if defined(__GXX_EXPERIMENTAL_CXX0X__) -# define BOOST_ASIO_HAS_STD_CHRONO -# if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) -# define BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) -# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) -# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) -# endif // defined(__GNUC__) -#endif // !defined(BOOST_ASIO_DISABLE_STD_CHRONO) +#if !defined(BOOST_ASIO_HAS_STD_CHRONO) +# if !defined(BOOST_ASIO_DISABLE_STD_CHRONO) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_CHRONO 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_CHRONO 1 +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) +# define BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK 1 +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_CHRONO 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_CHRONO) +#endif // !defined(BOOST_ASIO_HAS_STD_CHRONO) // Boost support for chrono. -#if !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) -# if (BOOST_VERSION >= 104700) -# define BOOST_ASIO_HAS_BOOST_CHRONO -# endif // (BOOST_VERSION >= 104700) -#endif // !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) +#if !defined(BOOST_ASIO_HAS_BOOST_CHRONO) +# if !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) +# if (BOOST_VERSION >= 104700) +# define BOOST_ASIO_HAS_BOOST_CHRONO 1 +# endif // (BOOST_VERSION >= 104700) +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) +#endif // !defined(BOOST_ASIO_HAS_BOOST_CHRONO) + +// Boost support for the DateTime library. +#if !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) +# if !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME) +# define BOOST_ASIO_HAS_BOOST_DATE_TIME 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME) +#endif // !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + +// Standard library support for addressof. +#if !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) +# if !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_ADDRESSOF 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_ADDRESSOF 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_ADDRESSOF 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF) +#endif // !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) + +// Standard library support for the function class. +#if !defined(BOOST_ASIO_HAS_STD_FUNCTION) +# if !defined(BOOST_ASIO_DISABLE_STD_FUNCTION) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_FUNCTION 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_FUNCTION 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_FUNCTION 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_FUNCTION) +#endif // !defined(BOOST_ASIO_HAS_STD_FUNCTION) + +// Standard library support for type traits. +#if !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) +# if !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS) +#endif // !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) + +// Standard library support for the cstdint header. +#if !defined(BOOST_ASIO_HAS_CSTDINT) +# if !defined(BOOST_ASIO_DISABLE_CSTDINT) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_CSTDINT 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_CSTDINT 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_CSTDINT 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_CSTDINT) +#endif // !defined(BOOST_ASIO_HAS_CSTDINT) + +// Standard library support for the thread class. +#if !defined(BOOST_ASIO_HAS_STD_THREAD) +# if !defined(BOOST_ASIO_DISABLE_STD_THREAD) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_THREAD 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_THREAD 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_THREAD 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_THREAD) +#endif // !defined(BOOST_ASIO_HAS_STD_THREAD) + +// Standard library support for the mutex and condition variable classes. +#if !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +# if !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR) +# if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 +# endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) +# if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) +# if defined(__GXX_EXPERIMENTAL_CXX0X__) +# define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 +# endif // defined(__GXX_EXPERIMENTAL_CXX0X__) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4) +# endif // defined(__GNUC__) +# if defined(BOOST_ASIO_MSVC) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) +# endif // !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR) +#endif // !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +// WinRT target. +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) +# if defined(__cplusplus_winrt) +# include <winapifamily.h> +# if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP) +# define BOOST_ASIO_WINDOWS_RUNTIME 1 +# endif // WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP) +# endif // defined(__cplusplus_winrt) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +// Windows target. Excludes WinRT. +#if !defined(BOOST_ASIO_WINDOWS) +# if !defined(BOOST_ASIO_WINDOWS_RUNTIME) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS) +# define BOOST_ASIO_WINDOWS 1 +# elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) +# define BOOST_ASIO_WINDOWS 1 +# endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS) +# endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) +#endif // !defined(BOOST_ASIO_WINDOWS) // Windows: target OS version. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS) # if defined(_MSC_VER) || defined(__BORLANDC__) # pragma message( \ "Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\ "- add -D_WIN32_WINNT=0x0501 to the compiler command line; or\n"\ "- add _WIN32_WINNT=0x0501 to your project's Preprocessor Definitions.\n"\ @@ -228,162 +509,398 @@ # endif // defined(__BORLANDC__) # if defined(__CYGWIN__) # if !defined(__USE_W32_SOCKETS) # error You must add -D__USE_W32_SOCKETS to your compiler options. # endif // !defined(__USE_W32_SOCKETS) # endif // defined(__CYGWIN__) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Windows: minimise header inclusion. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # if !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN) # if !defined(WIN32_LEAN_AND_MEAN) # define WIN32_LEAN_AND_MEAN # endif // !defined(WIN32_LEAN_AND_MEAN) # endif // !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Windows: suppress definition of "min" and "max" macros. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # if !defined(BOOST_ASIO_NO_NOMINMAX) # if !defined(NOMINMAX) # define NOMINMAX 1 # endif // !defined(NOMINMAX) # endif // !defined(BOOST_ASIO_NO_NOMINMAX) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Windows: IO Completion Ports. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) -# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) -# if !defined(UNDER_CE) -# if !defined(BOOST_ASIO_DISABLE_IOCP) -# define BOOST_ASIO_HAS_IOCP 1 -# endif // !defined(BOOST_ASIO_DISABLE_IOCP) -# endif // !defined(UNDER_CE) -# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if !defined(BOOST_ASIO_HAS_IOCP) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) +# if !defined(UNDER_CE) +# if !defined(BOOST_ASIO_DISABLE_IOCP) +# define BOOST_ASIO_HAS_IOCP 1 +# endif // !defined(BOOST_ASIO_DISABLE_IOCP) +# endif // !defined(UNDER_CE) +# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_HAS_IOCP) // Linux: epoll, eventfd and timerfd. #if defined(__linux__) # include <linux/version.h> -# if !defined(BOOST_ASIO_DISABLE_EPOLL) -# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) -# define BOOST_ASIO_HAS_EPOLL 1 -# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) -# endif // !defined(BOOST_ASIO_DISABLE_EVENTFD) -# if !defined(BOOST_ASIO_DISABLE_EVENTFD) -# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) -# define BOOST_ASIO_HAS_EVENTFD 1 -# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) -# endif // !defined(BOOST_ASIO_DISABLE_EVENTFD) -# if defined(BOOST_ASIO_HAS_EPOLL) -# if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) -# define BOOST_ASIO_HAS_TIMERFD 1 -# endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) -# endif // defined(BOOST_ASIO_HAS_EPOLL) +# if !defined(BOOST_ASIO_HAS_EPOLL) +# if !defined(BOOST_ASIO_DISABLE_EPOLL) +# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) +# define BOOST_ASIO_HAS_EPOLL 1 +# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) +# endif // !defined(BOOST_ASIO_DISABLE_EPOLL) +# endif // !defined(BOOST_ASIO_HAS_EPOLL) +# if !defined(BOOST_ASIO_HAS_EVENTFD) +# if !defined(BOOST_ASIO_DISABLE_EVENTFD) +# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) +# define BOOST_ASIO_HAS_EVENTFD 1 +# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) +# endif // !defined(BOOST_ASIO_DISABLE_EVENTFD) +# endif // !defined(BOOST_ASIO_HAS_EVENTFD) +# if !defined(BOOST_ASIO_HAS_TIMERFD) +# if defined(BOOST_ASIO_HAS_EPOLL) +# if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) +# define BOOST_ASIO_HAS_TIMERFD 1 +# endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) +# endif // defined(BOOST_ASIO_HAS_EPOLL) +# endif // !defined(BOOST_ASIO_HAS_TIMERFD) #endif // defined(__linux__) // Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue. #if (defined(__MACH__) && defined(__APPLE__)) \ || defined(__FreeBSD__) \ || defined(__NetBSD__) \ || defined(__OpenBSD__) -# if !defined(BOOST_ASIO_DISABLE_KQUEUE) -# define BOOST_ASIO_HAS_KQUEUE 1 -# endif // !defined(BOOST_ASIO_DISABLE_KQUEUE) +# if !defined(BOOST_ASIO_HAS_KQUEUE) +# if !defined(BOOST_ASIO_DISABLE_KQUEUE) +# define BOOST_ASIO_HAS_KQUEUE 1 +# endif // !defined(BOOST_ASIO_DISABLE_KQUEUE) +# endif // !defined(BOOST_ASIO_HAS_KQUEUE) #endif // (defined(__MACH__) && defined(__APPLE__)) // || defined(__FreeBSD__) // || defined(__NetBSD__) // || defined(__OpenBSD__) // Solaris: /dev/poll. #if defined(__sun) -# if !defined(BOOST_ASIO_DISABLE_DEV_POLL) -# define BOOST_ASIO_HAS_DEV_POLL 1 -# endif // !defined(BOOST_ASIO_DISABLE_DEV_POLL) +# if !defined(BOOST_ASIO_HAS_DEV_POLL) +# if !defined(BOOST_ASIO_DISABLE_DEV_POLL) +# define BOOST_ASIO_HAS_DEV_POLL 1 +# endif // !defined(BOOST_ASIO_DISABLE_DEV_POLL) +# endif // !defined(BOOST_ASIO_HAS_DEV_POLL) #endif // defined(__sun) // Serial ports. -#if defined(BOOST_ASIO_HAS_IOCP) \ - || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -# if !defined(__SYMBIAN32__) -# if !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) -# define BOOST_ASIO_HAS_SERIAL_PORT 1 -# endif // !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) -# endif // !defined(__SYMBIAN32__) -#endif // defined(BOOST_ASIO_HAS_IOCP) - // || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_HAS_SERIAL_PORT) +# if defined(BOOST_ASIO_HAS_IOCP) \ + || !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) +# if !defined(__SYMBIAN32__) +# if !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) +# define BOOST_ASIO_HAS_SERIAL_PORT 1 +# endif // !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) +# endif // !defined(__SYMBIAN32__) +# endif // defined(BOOST_ASIO_HAS_IOCP) + // || !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_HAS_SERIAL_PORT) // Windows: stream handles. -#if !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) -# if defined(BOOST_ASIO_HAS_IOCP) -# define BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE 1 -# endif // defined(BOOST_ASIO_HAS_IOCP) -#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) +#if !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) +# if !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) +# if defined(BOOST_ASIO_HAS_IOCP) +# define BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE 1 +# endif // defined(BOOST_ASIO_HAS_IOCP) +# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) +#endif // !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) // Windows: random access handles. -#if !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) -# if defined(BOOST_ASIO_HAS_IOCP) -# define BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1 -# endif // defined(BOOST_ASIO_HAS_IOCP) -#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) +#if !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) +# if !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) +# if defined(BOOST_ASIO_HAS_IOCP) +# define BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1 +# endif // defined(BOOST_ASIO_HAS_IOCP) +# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) +#endif // !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) // Windows: object handles. -#if !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) -# if defined(BOOST_WINDOWS) || defined(__CYGWIN__) -# if !defined(UNDER_CE) -# define BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE 1 -# endif // !defined(UNDER_CE) -# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) -#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) +#if !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) +# if !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if !defined(UNDER_CE) +# define BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE 1 +# endif // !defined(UNDER_CE) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) +#endif // !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) // Windows: OVERLAPPED wrapper. -#if !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) -# if defined(BOOST_ASIO_HAS_IOCP) -# define BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1 -# endif // defined(BOOST_ASIO_HAS_IOCP) -#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) +#if !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) +# if !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) +# if defined(BOOST_ASIO_HAS_IOCP) +# define BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1 +# endif // defined(BOOST_ASIO_HAS_IOCP) +# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) +#endif // !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) // POSIX: stream-oriented file descriptors. -#if !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) -# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -# define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1 -# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -#endif // !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) +#if !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) +# if !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) +# if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) +# define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1 +# endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) +# endif // !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) +#endif // !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) // UNIX domain sockets. -#if !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) -# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -# define BOOST_ASIO_HAS_LOCAL_SOCKETS 1 -# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -#endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) +#if !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) +# if !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) +# if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) +# define BOOST_ASIO_HAS_LOCAL_SOCKETS 1 +# endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) +# endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) +#endif // !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) // Can use sigaction() instead of signal(). -#if !defined(BOOST_ASIO_DISABLE_SIGACTION) -# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -# define BOOST_ASIO_HAS_SIGACTION 1 -# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) -#endif // !defined(BOOST_ASIO_DISABLE_SIGACTION) +#if !defined(BOOST_ASIO_HAS_SIGACTION) +# if !defined(BOOST_ASIO_DISABLE_SIGACTION) +# if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) +# define BOOST_ASIO_HAS_SIGACTION 1 +# endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) +# endif // !defined(BOOST_ASIO_DISABLE_SIGACTION) +#endif // !defined(BOOST_ASIO_HAS_SIGACTION) // Can use signal(). -#if !defined(BOOST_ASIO_DISABLE_SIGNAL) -# if !defined(UNDER_CE) -# define BOOST_ASIO_HAS_SIGNAL 1 -# endif // !defined(UNDER_CE) -#endif // !defined(BOOST_ASIO_DISABLE_SIGNAL) +#if !defined(BOOST_ASIO_HAS_SIGNAL) +# if !defined(BOOST_ASIO_DISABLE_SIGNAL) +# if !defined(UNDER_CE) +# define BOOST_ASIO_HAS_SIGNAL 1 +# endif // !defined(UNDER_CE) +# endif // !defined(BOOST_ASIO_DISABLE_SIGNAL) +#endif // !defined(BOOST_ASIO_HAS_SIGNAL) + +// Can use getaddrinfo() and getnameinfo(). +#if !defined(BOOST_ASIO_HAS_GETADDRINFO) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) +# define BOOST_ASIO_HAS_GETADDRINFO 1 +# elif defined(UNDER_CE) +# define BOOST_ASIO_HAS_GETADDRINFO 1 +# endif // defined(UNDER_CE) +# elif !(defined(__MACH__) && defined(__APPLE__)) +# define BOOST_ASIO_HAS_GETADDRINFO 1 +# endif // !(defined(__MACH__) && defined(__APPLE__)) +#endif // !defined(BOOST_ASIO_HAS_GETADDRINFO) + +// Whether standard iostreams are disabled. +#if !defined(BOOST_ASIO_NO_IOSTREAM) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_IOSTREAM) +# define BOOST_ASIO_NO_IOSTREAM 1 +# endif // !defined(BOOST_NO_IOSTREAM) +#endif // !defined(BOOST_ASIO_NO_IOSTREAM) + +// Whether exception handling is disabled. +#if !defined(BOOST_ASIO_NO_EXCEPTIONS) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_EXCEPTIONS) +# define BOOST_ASIO_NO_EXCEPTIONS 1 +# endif // !defined(BOOST_NO_EXCEPTIONS) +#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS) + +// Whether the typeid operator is supported. +#if !defined(BOOST_ASIO_NO_TYPEID) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_TYPEID) +# define BOOST_ASIO_NO_TYPEID 1 +# endif // !defined(BOOST_NO_TYPEID) +#endif // !defined(BOOST_ASIO_NO_TYPEID) + +// On POSIX (and POSIX-like) platforms we need to include unistd.h in order to +// get access to the various platform feature macros, e.g. to be able to test +// for threads support. +#if !defined(BOOST_ASIO_HAS_UNISTD_H) +# if !defined(BOOST_ASIO_HAS_BOOST_CONFIG) +# if defined(unix) \ + || defined(__unix) \ + || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) \ + || (defined(__MACH__) && defined(__APPLE__)) \ + || defined(__FreeBSD__) \ + || defined(__NetBSD__) \ + || defined(__OpenBSD__) \ + || defined(__linux__) +# define BOOST_ASIO_HAS_UNISTD_H 1 +# endif +# endif // !defined(BOOST_ASIO_HAS_BOOST_CONFIG) +#endif // !defined(BOOST_ASIO_HAS_UNISTD_H) +#if defined(BOOST_ASIO_HAS_UNISTD_H) +# include <unistd.h> +#endif // defined(BOOST_ASIO_HAS_UNISTD_H) + +// Threads. +#if !defined(BOOST_ASIO_HAS_THREADS) +# if !defined(BOOST_ASIO_DISABLE_THREADS) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS) +# define BOOST_ASIO_HAS_THREADS 1 +# elif defined(_MSC_VER) && defined(_MT) +# define BOOST_ASIO_HAS_THREADS 1 +# elif defined(__BORLANDC__) && defined(__MT__) +# define BOOST_ASIO_HAS_THREADS 1 +# elif defined(_POSIX_THREADS) +# define BOOST_ASIO_HAS_THREADS 1 +# endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS) +# endif // !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) + +// POSIX threads. +#if !defined(BOOST_ASIO_HAS_PTHREADS) +# if defined(BOOST_ASIO_HAS_THREADS) +# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS) +# define BOOST_ASIO_HAS_PTHREADS 1 +# elif defined(_POSIX_THREADS) +# define BOOST_ASIO_HAS_PTHREADS 1 +# endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS) +# endif // defined(BOOST_ASIO_HAS_THREADS) +#endif // !defined(BOOST_ASIO_HAS_PTHREADS) + +// Helper to prevent macro expansion. +#define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION + +// Helper to define in-class constants. +#if !defined(BOOST_ASIO_STATIC_CONSTANT) +# if !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) +# define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \ + BOOST_STATIC_CONSTANT(type, assignment) +# else // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) +# define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \ + static const type assignment +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) +#endif // !defined(BOOST_ASIO_STATIC_CONSTANT) + +// Boost array library. +#if !defined(BOOST_ASIO_HAS_BOOST_ARRAY) +# if !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY) +# define BOOST_ASIO_HAS_BOOST_ARRAY 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY) +#endif // !defined(BOOST_ASIO_HAS_BOOST_ARRAY) + +// Boost assert macro. +#if !defined(BOOST_ASIO_HAS_BOOST_ASSERT) +# if !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT) +# define BOOST_ASIO_HAS_BOOST_ASSERT 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT) +#endif // !defined(BOOST_ASIO_HAS_BOOST_ASSERT) + +// Boost limits header. +#if !defined(BOOST_ASIO_HAS_BOOST_LIMITS) +# if !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS) +# define BOOST_ASIO_HAS_BOOST_LIMITS 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS) +#endif // !defined(BOOST_ASIO_HAS_BOOST_LIMITS) + +// Boost throw_exception function. +#if !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) +# if !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION) +# define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION) +#endif // !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) + +// Boost regex library. +#if !defined(BOOST_ASIO_HAS_BOOST_REGEX) +# if !defined(BOOST_ASIO_DISABLE_BOOST_REGEX) +# define BOOST_ASIO_HAS_BOOST_REGEX 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_REGEX) +#endif // !defined(BOOST_ASIO_HAS_BOOST_REGEX) + +// Boost bind function. +#if !defined(BOOST_ASIO_HAS_BOOST_BIND) +# if !defined(BOOST_ASIO_DISABLE_BOOST_BIND) +# define BOOST_ASIO_HAS_BOOST_BIND 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_BIND) +#endif // !defined(BOOST_ASIO_HAS_BOOST_BIND) + +// Boost's BOOST_WORKAROUND macro. +#if !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND) +# if !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND) +# define BOOST_ASIO_HAS_BOOST_WORKAROUND 1 +# endif // !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND) +#endif // !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND) + +// Microsoft Visual C++'s secure C runtime library. +#if !defined(BOOST_ASIO_HAS_SECURE_RTL) +# if !defined(BOOST_ASIO_DISABLE_SECURE_RTL) +# if defined(BOOST_ASIO_MSVC) \ + && (BOOST_ASIO_MSVC >= 1400) \ + && !defined(UNDER_CE) +# define BOOST_ASIO_HAS_SECURE_RTL 1 +# endif // defined(BOOST_ASIO_MSVC) + // && (BOOST_ASIO_MSVC >= 1400) + // && !defined(UNDER_CE) +# endif // !defined(BOOST_ASIO_DISABLE_SECURE_RTL) +#endif // !defined(BOOST_ASIO_HAS_SECURE_RTL) + +// Handler hooking. Disabled for ancient Borland C++ and gcc compilers. +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) +# if !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS) +# if defined(__GNUC__) +# if (__GNUC__ >= 3) +# define BOOST_ASIO_HAS_HANDLER_HOOKS 1 +# endif // (__GNUC__ >= 3) +# elif !defined(__BORLANDC__) +# define BOOST_ASIO_HAS_HANDLER_HOOKS 1 +# endif // !defined(__BORLANDC__) +# endif // !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS) +#endif // !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) // Support for the __thread keyword extension. #if !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION) # if defined(__linux__) # if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) # if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3) # if !defined(__INTEL_COMPILER) && !defined(__ICL) # define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 +# define BOOST_ASIO_THREAD_KEYWORD __thread # elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) # define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 # endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) # endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3) # endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) # endif // defined(__linux__) +# if defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME) +# if (_MSC_VER >= 1700) +# define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 +# define BOOST_ASIO_THREAD_KEYWORD __declspec(thread) +# endif // (_MSC_VER >= 1700) +# endif // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION) +#if !defined(BOOST_ASIO_THREAD_KEYWORD) +# define BOOST_ASIO_THREAD_KEYWORD __thread +#endif // !defined(BOOST_ASIO_THREAD_KEYWORD) + +// Support for POSIX ssize_t typedef. +#if !defined(BOOST_ASIO_DISABLE_SSIZE_T) +# if defined(__linux__) \ + || (defined(__MACH__) && defined(__APPLE__)) +# define BOOST_ASIO_HAS_SSIZE_T 1 +# endif // defined(__linux__) + // || (defined(__MACH__) && defined(__APPLE__)) +#endif // !defined(BOOST_ASIO_DISABLE_SSIZE_T) #endif // BOOST_ASIO_DETAIL_CONFIG_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp b/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp index e13403f..8bd36e4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp @@ -1,11 +1,11 @@ // // detail/consuming_buffers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_CONSUMING_BUFFERS_HPP @@ -14,28 +14,42 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> -#include <boost/iterator.hpp> -#include <boost/limits.hpp> +#include <iterator> #include <boost/asio/buffer.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // A proxy iterator for a sub-range in a list of buffers. template <typename Buffer, typename Buffer_Iterator> class consuming_buffers_iterator - : public boost::iterator<std::forward_iterator_tag, const Buffer> { public: + /// The type used for the distance between two iterators. + typedef std::ptrdiff_t difference_type; + + /// The type of the value pointed to by the iterator. + typedef Buffer value_type; + + /// The type of the result of applying operator->() to the iterator. + typedef const Buffer* pointer; + + /// The type of the result of applying operator*() to the iterator. + typedef const Buffer& reference; + + /// The iterator category. + typedef std::forward_iterator_tag iterator_category; + // Default constructor creates an end iterator. consuming_buffers_iterator() : at_end_(true) { } diff --git a/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp b/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp new file mode 100644 index 0000000..ad611e9 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp @@ -0,0 +1,48 @@ +// +// detail/cstdint.hpp +// ~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_CSTDINT_HPP +#define BOOST_ASIO_DETAIL_CSTDINT_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_CSTDINT) +# include <cstdint> +#else // defined(BOOST_ASIO_HAS_CSTDINT) +# include <boost/cstdint.hpp> +#endif // defined(BOOST_ASIO_HAS_CSTDINT) + +namespace boost { +namespace asio { + +#if defined(BOOST_ASIO_HAS_CSTDINT) +using std::int16_t; +using std::uint16_t; +using std::int32_t; +using std::uint32_t; +using std::int64_t; +using std::uint64_t; +#else // defined(BOOST_ASIO_HAS_CSTDINT) +using boost::int16_t; +using boost::uint16_t; +using boost::int32_t; +using boost::uint32_t; +using boost::int64_t; +using boost::uint64_t; +#endif // defined(BOOST_ASIO_HAS_CSTDINT) + +} // namespace asio +} // namespace boost + +#endif // BOOST_ASIO_DETAIL_CSTDINT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp index 162ccdc..1c0bcaf 100644 --- a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp @@ -1,11 +1,11 @@ // // detail/date_time_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DATE_TIME_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp index 833815a..52e2639 100644 --- a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp @@ -1,11 +1,11 @@ // // detail/deadline_timer_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP @@ -16,22 +16,28 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue.hpp> #include <boost/asio/detail/timer_scheduler.hpp> #include <boost/asio/detail/wait_handler.hpp> #include <boost/asio/detail/wait_op.hpp> +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +# include <chrono> +# include <thread> +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -167,17 +173,17 @@ public: now = Time_Traits::now(); } } // Start an asynchronous wait on the timer. template <typename Handler> - void async_wait(implementation_type& impl, Handler handler) + void async_wait(implementation_type& impl, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef wait_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); impl.might_have_pending_waits = true; @@ -191,16 +197,23 @@ private: // Helper function to wait given a duration type. The duration type should // either be of type boost::posix_time::time_duration, or implement the // required subset of its interface. template <typename Duration> void do_wait(const Duration& timeout, boost::system::error_code& ec) { +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + std::this_thread::sleep_for( + std::chrono::seconds(timeout.total_seconds()) + + std::chrono::microseconds(timeout.total_microseconds())); + ec = boost::system::error_code(); +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) ::timeval tv; tv.tv_sec = timeout.total_seconds(); tv.tv_usec = timeout.total_microseconds() % 1000000; socket_ops::select(0, 0, 0, 0, &tv, ec); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } // The queue of timers. timer_queue<Time_Traits> timer_queue_; // The object that schedules and executes timers. Usually a reactor. diff --git a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp b/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp index c7b1c1b..a9e7fed 100644 --- a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp @@ -1,11 +1,11 @@ // // detail/dependent_type.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DEPENDENT_TYPE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp index 72ea6e2..b9fbadc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp @@ -1,11 +1,11 @@ // // detail/descriptor_ops.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DESCRIPTOR_OPS_HPP @@ -14,13 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) #include <cstddef> #include <boost/system/error_code.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> @@ -85,15 +87,15 @@ BOOST_ASIO_DECL bool non_blocking_write(int d, const buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred); BOOST_ASIO_DECL int ioctl(int d, state_type& state, long cmd, ioctl_arg_type* arg, boost::system::error_code& ec); -BOOST_ASIO_DECL int fcntl(int d, long cmd, boost::system::error_code& ec); +BOOST_ASIO_DECL int fcntl(int d, int cmd, boost::system::error_code& ec); -BOOST_ASIO_DECL int fcntl(int d, long cmd, +BOOST_ASIO_DECL int fcntl(int d, int cmd, long arg, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_read(int d, state_type state, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_write(int d, @@ -107,9 +109,11 @@ BOOST_ASIO_DECL int poll_write(int d, #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/descriptor_ops.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp index 9f4adff..6993bd6 100644 --- a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp @@ -1,11 +1,11 @@ // // detail/descriptor_read_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP @@ -14,15 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> @@ -78,25 +78,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. descriptor_read_op* o(static_cast<descriptor_read_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); @@ -113,9 +113,9 @@ private: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp index 88c80c8..ec83eef 100644 --- a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp @@ -1,11 +1,11 @@ // // detail/descriptor_write_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP @@ -14,15 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> @@ -78,25 +78,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. descriptor_write_op* o(static_cast<descriptor_write_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); @@ -113,9 +113,9 @@ private: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp index e6b6e12..379e390 100644 --- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp @@ -1,11 +1,11 @@ // // detail/dev_poll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_DEV_POLL_REACTOR_HPP @@ -16,26 +16,24 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_DEV_POLL) -#include <boost/limits.hpp> #include <cstddef> #include <vector> #include <sys/devpoll.h> -#include <boost/asio/detail/dev_poll_reactor_fwd.hpp> #include <boost/asio/detail/hash_map.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> -#include <boost/asio/detail/timer_queue_fwd.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/detail/push_options.hpp> @@ -84,21 +82,22 @@ public: // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. - void post_immediate_completion(reactor_op* op) + void post_immediate_completion(reactor_op* op, bool is_continuation) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, - per_descriptor_data&, reactor_op* op, bool allow_speculative); + per_descriptor_data&, reactor_op* op, + bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&); diff --git a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp deleted file mode 100644 index 026f91a..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// -// detail/dev_poll_reactor_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP -#define BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -#include <boost/asio/detail/config.hpp> - -#if defined(BOOST_ASIO_HAS_DEV_POLL) - -namespace boost { -namespace asio { -namespace detail { - -class dev_poll_reactor; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // defined(BOOST_ASIO_HAS_DEV_POLL) - -#endif // BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp index 8f66f74..976da8a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp @@ -1,11 +1,11 @@ // // detail/epoll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_EPOLL_REACTOR_HPP @@ -16,25 +16,22 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_EPOLL) -#include <boost/cstdint.hpp> -#include <boost/limits.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/detail/atomic_count.hpp> -#include <boost/asio/detail/epoll_reactor_fwd.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/object_pool.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> -#include <boost/asio/detail/timer_queue_fwd.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -57,13 +54,13 @@ public: descriptor_state* next_; descriptor_state* prev_; mutex mutex_; epoll_reactor* reactor_; int descriptor_; - boost::uint32_t registered_events_; + uint32_t registered_events_; op_queue<reactor_op> op_queue_[max_ops]; bool shutdown_; BOOST_ASIO_DECL descriptor_state(); void set_ready_events(uint32_t events) { task_result_ = events; } BOOST_ASIO_DECL operation* perform_io(uint32_t events); @@ -105,22 +102,22 @@ public: // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. - void post_immediate_completion(reactor_op* op) + void post_immediate_completion(reactor_op* op, bool is_continuation) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op, - bool allow_speculative); + bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data& descriptor_data); diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp deleted file mode 100644 index aa28271..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// -// detail/epoll_reactor_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP -#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -#include <boost/asio/detail/config.hpp> - -#if defined(BOOST_ASIO_HAS_EPOLL) - -namespace boost { -namespace asio { -namespace detail { - -class epoll_reactor; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // defined(BOOST_ASIO_HAS_EPOLL) - -#endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/event.hpp b/3rdParty/Boost/src/boost/asio/detail/event.hpp index 0ee6b6e..a18affe 100644 --- a/3rdParty/Boost/src/boost/asio/detail/event.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/event.hpp @@ -1,11 +1,11 @@ // // detail/event.hpp // ~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_EVENT_HPP @@ -14,32 +14,36 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) # include <boost/asio/detail/null_event.hpp> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_event.hpp> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_event.hpp> +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +# include <boost/asio/detail/std_event.hpp> #else -# error Only Windows and POSIX are supported! +# error Only Windows, POSIX and std::condition_variable are supported! #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) typedef null_event event; -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) typedef win_event event; -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_event event; +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +typedef std_event event; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp index cf40eee..7012372 100644 --- a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp @@ -1,11 +1,11 @@ // // detail/eventfd_select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com) // // 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) // diff --git a/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp index 51fe927..7aebdef 100644 --- a/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp @@ -1,11 +1,11 @@ // // detail/fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_FD_SET_ADAPTER_HPP @@ -13,24 +13,29 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> + +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #include <boost/asio/detail/posix_fd_set_adapter.hpp> #include <boost/asio/detail/win_fd_set_adapter.hpp> namespace boost { namespace asio { namespace detail { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef win_fd_set_adapter fd_set_adapter; #else typedef posix_fd_set_adapter fd_set_adapter; #endif } // namespace detail } // namespace asio } // namespace boost +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #endif // BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp index d9e8a04..1ee26cf 100644 --- a/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_FENCED_BLOCK_HPP @@ -14,14 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) \ - || defined(BOOST_ASIO_DISABLE_THREADS) \ +#if !defined(BOOST_ASIO_HAS_THREADS) \ || defined(BOOST_ASIO_DISABLE_FENCED_BLOCK) # include <boost/asio/detail/null_fenced_block.hpp> #elif defined(__MACH__) && defined(__APPLE__) # include <boost/asio/detail/macos_fenced_block.hpp> #elif defined(__sun) # include <boost/asio/detail/solaris_fenced_block.hpp> @@ -34,24 +33,23 @@ # include <boost/asio/detail/gcc_x86_fenced_block.hpp> #elif defined(__GNUC__) \ && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \ && !defined(__INTEL_COMPILER) && !defined(__ICL) \ && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__) # include <boost/asio/detail/gcc_sync_fenced_block.hpp> -#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) # include <boost/asio/detail/win_fenced_block.hpp> #else # include <boost/asio/detail/null_fenced_block.hpp> #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) \ - || defined(BOOST_ASIO_DISABLE_THREADS) \ +#if !defined(BOOST_ASIO_HAS_THREADS) \ || defined(BOOST_ASIO_DISABLE_FENCED_BLOCK) typedef null_fenced_block fenced_block; #elif defined(__MACH__) && defined(__APPLE__) typedef macos_fenced_block fenced_block; #elif defined(__sun) typedef solaris_fenced_block fenced_block; @@ -64,13 +62,13 @@ typedef gcc_hppa_fenced_block fenced_block; typedef gcc_x86_fenced_block fenced_block; #elif defined(__GNUC__) \ && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \ && !defined(__INTEL_COMPILER) && !defined(__ICL) \ && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__) typedef gcc_sync_fenced_block fenced_block; -#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) typedef win_fenced_block fenced_block; #else typedef null_fenced_block fenced_block; #endif } // namespace detail diff --git a/3rdParty/Boost/src/boost/asio/detail/function.hpp b/3rdParty/Boost/src/boost/asio/detail/function.hpp new file mode 100644 index 0000000..1edcb1b --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/function.hpp @@ -0,0 +1,40 @@ +// +// detail/function.hpp +// ~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_FUNCTION_HPP +#define BOOST_ASIO_DETAIL_FUNCTION_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_FUNCTION) +# include <functional> +#else // defined(BOOST_ASIO_HAS_STD_FUNCTION) +# include <boost/function.hpp> +#endif // defined(BOOST_ASIO_HAS_STD_FUNCTION) + +namespace boost { +namespace asio { +namespace detail { + +#if defined(BOOST_ASIO_HAS_STD_FUNCTION) +using std::function; +#else // defined(BOOST_ASIO_HAS_STD_FUNCTION) +using boost::function; +#endif // defined(BOOST_ASIO_HAS_STD_FUNCTION) + +} // namespace detail +} // namespace asio +} // namespace boost + +#endif // BOOST_ASIO_DETAIL_FUNCTION_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp index 1b3c764..5d5fc5c 100644 --- a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/gcc_arm_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp index 421d3a6..61ad438 100644 --- a/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/gcc_hppa_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp index 81aaeb0..226cfa7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/gcc_sync_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp index 973165a..d39c693 100644 --- a/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/gcc_x86_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP @@ -61,22 +61,30 @@ private: return r; } static void lbarrier() { #if defined(__SSE2__) +# if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) + __builtin_ia32_lfence(); +# else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __asm__ __volatile__ ("lfence" ::: "memory"); +# endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) #else // defined(__SSE2__) barrier(); #endif // defined(__SSE2__) } static void sbarrier() { #if defined(__SSE2__) +# if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) + __builtin_ia32_sfence(); +# else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __asm__ __volatile__ ("sfence" ::: "memory"); +# endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) #else // defined(__SSE2__) barrier(); #endif // defined(__SSE2__) } }; diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp index 91e993c..dac3737 100644 --- a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp @@ -1,11 +1,11 @@ // // detail/handler_alloc_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP @@ -13,14 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/detail/workaround.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/handler_alloc_hook.hpp> #include <boost/asio/detail/push_options.hpp> // Calls to asio_handler_allocate and asio_handler_deallocate must be made from @@ -28,30 +27,28 @@ // boost_asio_handler_alloc_helpers namespace is defined here for that purpose. namespace boost_asio_handler_alloc_helpers { template <typename Handler> inline void* allocate(std::size_t s, Handler& h) { -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \ - || BOOST_WORKAROUND(__GNUC__, < 3) +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) return ::operator new(s); #else using boost::asio::asio_handler_allocate; - return asio_handler_allocate(s, boost::addressof(h)); + return asio_handler_allocate(s, boost::asio::detail::addressof(h)); #endif } template <typename Handler> inline void deallocate(void* p, std::size_t s, Handler& h) { -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \ - || BOOST_WORKAROUND(__GNUC__, < 3) +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) ::operator delete(p); #else using boost::asio::asio_handler_deallocate; - asio_handler_deallocate(p, s, boost::addressof(h)); + asio_handler_deallocate(p, s, boost::asio::detail::addressof(h)); #endif } } // namespace boost_asio_handler_alloc_helpers #define BOOST_ASIO_DEFINE_HANDLER_PTR(op) \ diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp new file mode 100644 index 0000000..e318a6e --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp @@ -0,0 +1,45 @@ +// +// detail/handler_cont_helpers.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP +#define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/handler_continuation_hook.hpp> + +#include <boost/asio/detail/push_options.hpp> + +// Calls to asio_handler_is_continuation must be made from a namespace that +// does not contain overloads of this function. This namespace is defined here +// for that purpose. +namespace boost_asio_handler_cont_helpers { + +template <typename Context> +inline bool is_continuation(Context& context) +{ +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) + return false; +#else + using boost::asio::asio_handler_is_continuation; + return asio_handler_is_continuation( + boost::asio::detail::addressof(context)); +#endif +} + +} // namespace boost_asio_handler_cont_helpers + +#include <boost/asio/detail/pop_options.hpp> + +#endif // BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp index f6172a0..ed276e5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp @@ -1,11 +1,11 @@ // // detail/handler_invoke_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP @@ -13,46 +13,43 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/detail/workaround.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/handler_invoke_hook.hpp> #include <boost/asio/detail/push_options.hpp> // Calls to asio_handler_invoke must be made from a namespace that does not // contain overloads of this function. The boost_asio_handler_invoke_helpers // namespace is defined here for that purpose. namespace boost_asio_handler_invoke_helpers { template <typename Function, typename Context> inline void invoke(Function& function, Context& context) { -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \ - || BOOST_WORKAROUND(__GNUC__, < 3) +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) Function tmp(function); tmp(); #else using boost::asio::asio_handler_invoke; - asio_handler_invoke(function, boost::addressof(context)); + asio_handler_invoke(function, boost::asio::detail::addressof(context)); #endif } template <typename Function, typename Context> inline void invoke(const Function& function, Context& context) { -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \ - || BOOST_WORKAROUND(__GNUC__, < 3) +#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) Function tmp(function); tmp(); #else using boost::asio::asio_handler_invoke; - asio_handler_invoke(function, boost::addressof(context)); + asio_handler_invoke(function, boost::asio::detail::addressof(context)); #endif } } // namespace boost_asio_handler_invoke_helpers #include <boost/asio/detail/pop_options.hpp> diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp index 9c96e18..9f31ddc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp @@ -1,11 +1,11 @@ // // detail/handler_tracking.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_HANDLER_TRACKING_HPP @@ -15,14 +15,14 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) -# include <boost/cstdint.hpp> # include <boost/system/error_code.hpp> +# include <boost/asio/detail/cstdint.hpp> # include <boost/asio/detail/static_mutex.hpp> # include <boost/asio/detail/tss_ptr.hpp> #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #include <boost/asio/detail/push_options.hpp> @@ -41,13 +41,13 @@ public: class tracked_handler { private: // Only the handler_tracking class will have access to the id. friend class handler_tracking; friend class completion; - boost::uint64_t id_; + uint64_t id_; protected: // Constructor initialises with no id. tracked_handler() : id_(0) {} // Prevent deletion through this type. @@ -91,13 +91,13 @@ public: // Record that handler invocation has ended. BOOST_ASIO_DECL void invocation_end(); private: friend class handler_tracking; - boost::uint64_t id_; + uint64_t id_; bool invoked_; completion* next_; }; // Record an operation that affects pending handlers. BOOST_ASIO_DECL static void operation(const char* object_type, diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp index a7f47c2..da111f1 100644 --- a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp @@ -1,11 +1,11 @@ // // detail/handler_type_requirements.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP @@ -34,19 +34,38 @@ # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) # if defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 # endif // defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4) # endif // defined(__GNUC__) -# if defined(BOOST_MSVC) +# if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1600) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 # endif // (_MSC_VER >= 1600) -# endif // defined(BOOST_MSVC) +# endif // defined(BOOST_ASIO_MSVC) +# if defined(__clang__) +# if __has_feature(__cxx_static_assert__) +# define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 +# endif // __has_feature(cxx_static_assert) +# endif // defined(__clang__) #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS) +#if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) +# include <boost/asio/handler_type.hpp> +#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) + +// Newer gcc needs special treatment to suppress unused typedef warnings. +#if defined(__GNUC__) +# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4) +# define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__)) +# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4) +#endif // defined(__GNUC__) +#if !defined(BOOST_ASIO_UNUSED_TYPEDEF) +# define BOOST_ASIO_UNUSED_TYPEDEF +#endif // !defined(BOOST_ASIO_UNUSED_TYPEDEF) + namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) @@ -90,271 +109,380 @@ char (&two_arg_handler_test(Handler, ...))[2]; # define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) # endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT) template <typename T> T& lvref(); template <typename T> T& lvref(T); +template <typename T> const T& clvref(); template <typename T> const T& clvref(T); template <typename T> char argbyv(T); template <int> struct handler_type_requirements { }; #define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void()) asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::zero_arg_handler_test( \ - handler, 0)) == 1, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), 0)) == 1, \ "CompletionHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)(), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()(), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_READ_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, std::size_t)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0), \ static_cast<const std::size_t*>(0))) == 1, \ "ReadHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>(), \ - boost::asio::detail::lvref<const std::size_t>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const std::size_t>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF + #define BOOST_ASIO_WRITE_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, std::size_t)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0), \ static_cast<const std::size_t*>(0))) == 1, \ "WriteHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>(), \ - boost::asio::detail::lvref<const std::size_t>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const std::size_t>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0))) == 1, \ "AcceptHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0))) == 1, \ "ConnectHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \ handler_type, handler, iter_type) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, iter_type)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0), \ static_cast<const iter_type*>(0))) == 1, \ "ComposedConnectHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>(), \ - boost::asio::detail::lvref<const iter_type>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const iter_type>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \ handler_type, handler, iter_type) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, iter_type)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0), \ static_cast<const iter_type*>(0))) == 1, \ "ResolveHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>(), \ - boost::asio::detail::lvref<const iter_type>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const iter_type>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WAIT_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0))) == 1, \ "WaitHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, int)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0), \ static_cast<const int*>(0))) == 1, \ "SignalHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>(), \ - boost::asio::detail::lvref<const int>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const int>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0))) == 1, \ "HandshakeHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF + +#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \ + handler_type, handler) \ + \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code, std::size_t)) \ + asio_true_handler_type; \ + \ + BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ + sizeof(boost::asio::detail::two_arg_handler_test( \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ + static_cast<const boost::system::error_code*>(0), \ + static_cast<const std::size_t*>(0))) == 1, \ + "BufferedHandshakeHandler type requirements not met") \ + \ + typedef boost::asio::detail::handler_type_requirements< \ + sizeof( \ + boost::asio::detail::argbyv( \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ + sizeof( \ + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>(), \ + boost::asio::detail::lvref<const std::size_t>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \ handler_type, handler) \ \ + typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ + void(boost::system::error_code)) \ + asio_true_handler_type; \ + \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ - handler, \ + boost::asio::detail::clvref< \ + asio_true_handler_type>(), \ static_cast<const boost::system::error_code*>(0))) == 1, \ "ShutdownHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ - boost::asio::detail::clvref(handler))) + \ + boost::asio::detail::clvref< \ + asio_true_handler_type>())) + \ sizeof( \ - boost::asio::detail::lvref(handler)( \ - boost::asio::detail::lvref<const boost::system::error_code>()), \ - char(0))> + boost::asio::detail::lvref< \ + asio_true_handler_type>()( \ + boost::asio::detail::lvref<const boost::system::error_code>()), \ + char(0))> BOOST_ASIO_UNUSED_TYPEDEF #else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) #define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_READ_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WRITE_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \ handler_type, handler, iter_type) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \ handler_type, handler, iter_type) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WAIT_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF + +#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \ + handler_type, handler) \ + typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \ handler_type, handler) \ - typedef int + typedef int BOOST_ASIO_UNUSED_TYPEDEF #endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp index 339ab9d..6724a24 100644 --- a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp @@ -1,11 +1,11 @@ // // detail/hash_map.hpp // ~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_HASH_MAP_HPP @@ -13,20 +13,20 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/assert.hpp> #include <list> #include <utility> +#include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # include <boost/asio/detail/socket_types.hpp> -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -39,18 +39,18 @@ inline std::size_t calculate_hash_value(int i) inline std::size_t calculate_hash_value(void* p) { return reinterpret_cast<std::size_t>(p) + (reinterpret_cast<std::size_t>(p) >> 3); } -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) inline std::size_t calculate_hash_value(SOCKET s) { return static_cast<std::size_t>(s); } -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Note: assumes K and V are POD types. template <typename K, typename V> class hash_map : private noncopyable { @@ -177,13 +177,14 @@ public: return std::pair<iterator, bool>(buckets_[bucket].last, true); } // Erase an entry from the map. void erase(iterator it) { - BOOST_ASSERT(it != values_.end()); + BOOST_ASIO_ASSERT(it != values_.end()); + BOOST_ASIO_ASSERT(num_buckets_ != 0); size_t bucket = calculate_hash_value(it->first) % num_buckets_; bool is_first = (it == buckets_[bucket].first); bool is_last = (it == buckets_[bucket].last); if (is_first && is_last) buckets_[bucket].first = buckets_[bucket].last = values_.end(); @@ -241,12 +242,13 @@ private: // Re-initialise the hash from the values already contained in the list. void rehash(std::size_t num_buckets) { if (num_buckets == num_buckets_) return; num_buckets_ = num_buckets; + BOOST_ASIO_ASSERT(num_buckets_ != 0); iterator end_iter = values_.end(); // Update number of buckets and initialise all buckets to empty. bucket_type* tmp = new bucket_type[num_buckets_]; delete[] buckets_; diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp new file mode 100644 index 0000000..a538134 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp @@ -0,0 +1,120 @@ +// +// detail/impl/buffer_sequence_adapter.ipp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP +#define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <robuffer.h> +#include <windows.storage.streams.h> +#include <wrl/implements.h> +#include <boost/asio/detail/buffer_sequence_adapter.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class winrt_buffer_impl : + public Microsoft::WRL::RuntimeClass< + Microsoft::WRL::RuntimeClassFlags< + Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>, + ABI::Windows::Storage::Streams::IBuffer, + Windows::Storage::Streams::IBufferByteAccess> +{ +public: + explicit winrt_buffer_impl(const boost::asio::const_buffer& b) + { + bytes_ = const_cast<byte*>(boost::asio::buffer_cast<const byte*>(b)); + length_ = boost::asio::buffer_size(b); + capacity_ = boost::asio::buffer_size(b); + } + + explicit winrt_buffer_impl(const boost::asio::mutable_buffer& b) + { + bytes_ = const_cast<byte*>(boost::asio::buffer_cast<const byte*>(b)); + length_ = 0; + capacity_ = boost::asio::buffer_size(b); + } + + ~winrt_buffer_impl() + { + } + + STDMETHODIMP Buffer(byte** value) + { + *value = bytes_; + return S_OK; + } + + STDMETHODIMP get_Capacity(UINT32* value) + { + *value = capacity_; + return S_OK; + } + + STDMETHODIMP get_Length(UINT32 *value) + { + *value = length_; + return S_OK; + } + + STDMETHODIMP put_Length(UINT32 value) + { + if (value > capacity_) + return E_INVALIDARG; + length_ = value; + return S_OK; + } + +private: + byte* bytes_; + UINT32 length_; + UINT32 capacity_; +}; + +void buffer_sequence_adapter_base::init_native_buffer( + buffer_sequence_adapter_base::native_buffer_type& buf, + const boost::asio::mutable_buffer& buffer) +{ + std::memset(&buf, 0, sizeof(native_buffer_type)); + Microsoft::WRL::ComPtr<IInspectable> insp + = Microsoft::WRL::Make<winrt_buffer_impl>(buffer); + buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get()); +} + +void buffer_sequence_adapter_base::init_native_buffer( + buffer_sequence_adapter_base::native_buffer_type& buf, + const boost::asio::const_buffer& buffer) +{ + std::memset(&buf, 0, sizeof(native_buffer_type)); + Microsoft::WRL::ComPtr<IInspectable> insp + = Microsoft::WRL::Make<winrt_buffer_impl>(buffer); + Platform::Object^ buf_obj = reinterpret_cast<Platform::Object^>(insp.Get()); + buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get()); +} + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp index 6c3528f..54b8537 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp @@ -1,11 +1,11 @@ // // detail/impl/descriptor_ops.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP @@ -17,13 +17,15 @@ #include <boost/asio/detail/config.hpp> #include <cerrno> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/error.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -180,13 +182,14 @@ std::size_t sync_read(int d, state_type state, buf* bufs, // Read some data. for (;;) { // Try to complete the operation without blocking. errno = 0; - int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec); + signed_size_type bytes = error_wrapper(::readv( + d, bufs, static_cast<int>(count)), ec); // Check if operation succeeded. if (bytes > 0) return bytes; // Check for EOF. @@ -212,13 +215,14 @@ bool non_blocking_read(int d, buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Read some data. errno = 0; - int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec); + signed_size_type bytes = error_wrapper(::readv( + d, bufs, static_cast<int>(count)), ec); // Check for end of stream. if (bytes == 0) { ec = boost::asio::error::eof; return true; @@ -264,13 +268,14 @@ std::size_t sync_write(int d, state_type state, const buf* bufs, // Write some data. for (;;) { // Try to complete the operation without blocking. errno = 0; - int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec); + signed_size_type bytes = error_wrapper(::writev( + d, bufs, static_cast<int>(count)), ec); // Check if operation succeeded. if (bytes > 0) return bytes; // Operation failed. @@ -289,13 +294,14 @@ bool non_blocking_write(int d, const buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Write some data. errno = 0; - int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec); + signed_size_type bytes = error_wrapper(::writev( + d, bufs, static_cast<int>(count)), ec); // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. @@ -354,13 +360,13 @@ int ioctl(int d, state_type& state, long cmd, } } return result; } -int fcntl(int d, long cmd, boost::system::error_code& ec) +int fcntl(int d, int cmd, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } @@ -369,13 +375,13 @@ int fcntl(int d, long cmd, boost::system::error_code& ec) int result = error_wrapper(::fcntl(d, cmd), ec); if (result != -1) ec = boost::system::error_code(); return result; } -int fcntl(int d, long cmd, long arg, boost::system::error_code& ec) +int fcntl(int d, int cmd, long arg, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } @@ -437,9 +443,11 @@ int poll_write(int d, state_type state, boost::system::error_code& ec) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp index 12860af..1c02ea4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp @@ -1,11 +1,11 @@ // // detail/impl/dev_poll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP @@ -43,13 +43,13 @@ void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); io_service_.work_started(); if (earliest) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp index a648bf1..cc5b401 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp @@ -1,11 +1,11 @@ // // detail/impl/dev_poll_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP @@ -16,14 +16,14 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_DEV_POLL) -#include <boost/assert.hpp> #include <boost/asio/detail/dev_poll_reactor.hpp> +#include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -119,13 +119,13 @@ void dev_poll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev) fork_helper except_op_helper(this, POLLERR | POLLHUP | POLLPRI); op_queue_[except_op].get_descriptors(except_op_helper, ops); interrupter_.interrupt(); // The ops op_queue will always be empty because the fork_helper's set() // member function never returns false. - BOOST_ASSERT(ops.empty()); + BOOST_ASIO_ASSERT(ops.empty()); } } void dev_poll_reactor::init_task() { io_service_.init_task(); @@ -160,33 +160,33 @@ void dev_poll_reactor::move_descriptor(socket_type, dev_poll_reactor::per_descriptor_data&, dev_poll_reactor::per_descriptor_data&) { } void dev_poll_reactor::start_op(int op_type, socket_type descriptor, - dev_poll_reactor::per_descriptor_data&, - reactor_op* op, bool allow_speculative) + dev_poll_reactor::per_descriptor_data&, reactor_op* op, + bool is_continuation, bool allow_speculative) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } if (allow_speculative) { if (op_type != read_op || !op_queue_[except_op].has_operation(descriptor)) { if (!op_queue_[op_type].has_operation(descriptor)) { if (op->perform()) { lock.unlock(); - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); return; } } } } diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp index 215f484..3a08f8e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp @@ -1,11 +1,11 @@ // // detail/impl/epoll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP @@ -41,13 +41,13 @@ void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { mutex::scoped_lock lock(mutex_); if (shutdown_) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); io_service_.work_started(); if (earliest) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp index 073bd08..27408e4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp @@ -1,11 +1,11 @@ // // detail/impl/epoll_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP @@ -201,40 +201,40 @@ void epoll_reactor::move_descriptor(socket_type, { target_descriptor_data = source_descriptor_data; source_descriptor_data = 0; } void epoll_reactor::start_op(int op_type, socket_type descriptor, - epoll_reactor::per_descriptor_data& descriptor_data, - reactor_op* op, bool allow_speculative) + epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op, + bool is_continuation, bool allow_speculative) { if (!descriptor_data) { op->ec_ = boost::asio::error::bad_descriptor; - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (descriptor_data->shutdown_) { - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } if (descriptor_data->op_queue_[op_type].empty()) { if (allow_speculative && (op_type != read_op || descriptor_data->op_queue_[except_op].empty())) { if (op->perform()) { descriptor_lock.unlock(); - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); return; } if (op_type == write_op) { if ((descriptor_data->registered_events_ & EPOLLOUT) == 0) @@ -247,13 +247,13 @@ void epoll_reactor::start_op(int op_type, socket_type descriptor, descriptor_data->registered_events_ |= ev.events; } else { op->ec_ = boost::system::error_code(errno, boost::asio::error::get_system_category()); - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); return; } } } } else @@ -604,14 +604,15 @@ epoll_reactor::descriptor_state::descriptor_state() : operation(&epoll_reactor::descriptor_state::do_complete) { } operation* epoll_reactor::descriptor_state::perform_io(uint32_t events) { + mutex_.lock(); perform_io_cleanup_on_block_exit io_cleanup(reactor_); - mutex::scoped_lock descriptor_lock(mutex_); + mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock); // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI }; for (int j = max_ops - 1; j >= 0; --j) { diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp index 22154bb..c5a673a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp @@ -1,11 +1,11 @@ // // detail/impl/eventfd_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com) // // 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) // @@ -25,12 +25,13 @@ #include <fcntl.h> #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 # include <asm/unistd.h> #else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 # include <sys/eventfd.h> #endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 +#include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/eventfd_select_interrupter.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp index 70342e3..2c84e5a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp @@ -1,11 +1,11 @@ // // detail/impl/handler_tracking.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP @@ -20,30 +20,65 @@ #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #include <cstdarg> #include <cstdio> #include <boost/asio/detail/handler_tracking.hpp> -#include <boost/asio/detail/push_options.hpp> -#include <boost/date_time/posix_time/posix_time_types.hpp> -#include <boost/asio/detail/pop_options.hpp> - -#if !defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) +# include <boost/asio/time_traits.hpp> +#else // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) +# if defined(BOOST_ASIO_HAS_STD_CHRONO) +# include <chrono> +# elif defined(BOOST_ASIO_HAS_BOOST_CHRONO) +# include <boost/chrono/system_clocks.hpp> +# endif +# include <boost/asio/detail/chrono_time_traits.hpp> +# include <boost/asio/wait_traits.hpp> +#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + +#if !defined(BOOST_ASIO_WINDOWS) # include <unistd.h> -#endif // !defined(BOOST_WINDOWS) +#endif // !defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { +struct handler_tracking_timestamp +{ + uint64_t seconds; + uint64_t microseconds; + + handler_tracking_timestamp() + { +#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); + boost::posix_time::time_duration now = + boost::posix_time::microsec_clock::universal_time() - epoch; +#elif defined(BOOST_ASIO_HAS_STD_CHRONO) + typedef chrono_time_traits<std::chrono::system_clock, + boost::asio::wait_traits<std::chrono::system_clock> > traits_helper; + traits_helper::posix_time_duration now( + std::chrono::system_clock::now().time_since_epoch()); +#elif defined(BOOST_ASIO_HAS_BOOST_CHRONO) + typedef chrono_time_traits<boost::chrono::system_clock, + boost::asio::wait_traits<boost::chrono::system_clock> > traits_helper; + traits_helper::posix_time_duration now( + boost::chrono::system_clock::now().time_since_epoch()); +#endif + seconds = static_cast<uint64_t>(now.total_seconds()); + microseconds = static_cast<uint64_t>(now.total_microseconds() % 1000000); + } +}; + struct handler_tracking::tracking_state { static_mutex mutex_; - boost::uint64_t next_id_; + uint64_t next_id_; tss_ptr<completion>* current_completion_; }; handler_tracking::tracking_state* handler_tracking::get_state() { static tracking_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, 1, 0 }; @@ -67,28 +102,25 @@ void handler_tracking::creation(handler_tracking::tracked_handler* h, static tracking_state* state = get_state(); static_mutex::scoped_lock lock(state->mutex_); h->id_ = state->next_id_++; lock.unlock(); - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; - boost::uint64_t current_id = 0; + uint64_t current_id = 0; if (completion* current_completion = *state->current_completion_) current_id = current_completion->id_; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|%llu*%llu|%.20s@%p.%.50s\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, current_id, h->id_, object_type, object, op_name); } handler_tracking::completion::completion(handler_tracking::tracked_handler* h) : id_(h->id_), invoked_(false), @@ -98,197 +130,173 @@ handler_tracking::completion::completion(handler_tracking::tracked_handler* h) } handler_tracking::completion::~completion() { if (id_) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|%c%I64u|\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|%c%llu|\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, invoked_ ? '!' : '~', id_); } *get_state()->current_completion_ = next_; } void handler_tracking::completion::invocation_begin() { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|>%I64u|\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|>%llu|\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_); +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|>%llu|ec=%.20s:%d\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value()); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, std::size_t bytes_transferred) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,bytes_transferred=%I64u\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,bytes_transferred=%llu\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), - static_cast<boost::uint64_t>(bytes_transferred)); + static_cast<uint64_t>(bytes_transferred)); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, int signal_number) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,signal_number=%d\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,signal_number=%d\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), signal_number); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, const char* arg) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,%.50s\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,%.50s\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), arg); invoked_ = true; } void handler_tracking::completion::invocation_end() { if (id_) { - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|<%I64u|\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|<%llu|\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_); +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, id_); id_ = 0; } } void handler_tracking::operation(const char* object_type, void* object, const char* op_name) { static tracking_state* state = get_state(); - boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); - boost::posix_time::time_duration now = - boost::posix_time::microsec_clock::universal_time() - epoch; + handler_tracking_timestamp timestamp; unsigned long long current_id = 0; if (completion* current_completion = *state->current_completion_) current_id = current_completion->id_; write_line( -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) "@asio|%I64u.%06I64u|%I64u|%.20s@%p.%.50s\n", -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) "@asio|%llu.%06llu|%llu|%.20s@%p.%.50s\n", -#endif // defined(BOOST_WINDOWS) - static_cast<boost::uint64_t>(now.total_seconds()), - static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), +#endif // defined(BOOST_ASIO_WINDOWS) + timestamp.seconds, timestamp.microseconds, current_id, object_type, object, op_name); } void handler_tracking::write_line(const char* format, ...) { using namespace std; // For sprintf (or equivalent). va_list args; va_start(args, format); char line[256] = ""; -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_HAS_SECURE_RTL) int length = vsprintf_s(line, sizeof(line), format, args); -#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#else // defined(BOOST_ASIO_HAS_SECURE_RTL) int length = vsprintf(line, format, args); -#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#endif // defined(BOOST_ASIO_HAS_SECURE_RTL) va_end(args); -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE); DWORD bytes_written = 0; ::WriteFile(stderr_handle, line, length, &bytes_written, 0); -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) ::write(STDERR_FILENO, line, length); -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) } } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp index d3445cd..889ae26 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp @@ -1,11 +1,11 @@ // // detail/impl/kqueue_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com) // // 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) // @@ -45,13 +45,13 @@ void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); io_service_.work_started(); if (earliest) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp index a819eb9..7a026a9 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp @@ -1,11 +1,11 @@ // // detail/impl/kqueue_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com) // // 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) // @@ -44,16 +44,21 @@ kqueue_reactor::kqueue_reactor(boost::asio::io_service& io_service) io_service_(use_service<io_service_impl>(io_service)), mutex_(), kqueue_fd_(do_kqueue_create()), interrupter_(), shutdown_(false) { - // The interrupter is put into a permanently readable state. Whenever we want - // to interrupt the blocked kevent call we register a read operation against - // the descriptor. - interrupter_.interrupt(); + struct kevent event; + BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(), + EVFILT_READ, EV_ADD, 0, 0, &interrupter_); + if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1) + { + boost::system::error_code error(errno, + boost::asio::error::get_system_category()); + boost::asio::detail::throw_error(error); + } } kqueue_reactor::~kqueue_reactor() { close(kqueue_fd_); } @@ -86,32 +91,33 @@ void kqueue_reactor::fork_service(boost::asio::io_service::fork_event fork_ev) // The kqueue descriptor is automatically closed in the child. kqueue_fd_ = -1; kqueue_fd_ = do_kqueue_create(); interrupter_.recreate(); + struct kevent event; + BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(), + EVFILT_READ, EV_ADD, 0, 0, &interrupter_); + if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1) + { + boost::system::error_code error(errno, + boost::asio::error::get_system_category()); + boost::asio::detail::throw_error(error); + } + // Re-register all descriptors with kqueue. mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); for (descriptor_state* state = registered_descriptors_.first(); state != 0; state = state->next_) { struct kevent events[2]; - int num_events = 0; - - if (!state->op_queue_[read_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_, - EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state); - else if (!state->op_queue_[except_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_, - EVFILT_READ, EV_ADD | EV_CLEAR, EV_OOBAND, 0, state); - - if (!state->op_queue_[write_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_, - EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state); - - if (num_events && ::kevent(kqueue_fd_, events, num_events, 0, 0, 0) == -1) + BOOST_ASIO_KQUEUE_EV_SET(&events[0], state->descriptor_, + EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state); + BOOST_ASIO_KQUEUE_EV_SET(&events[1], state->descriptor_, + EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state); + if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1) { boost::system::error_code error(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(error); } } @@ -130,12 +136,20 @@ int kqueue_reactor::register_descriptor(socket_type descriptor, mutex::scoped_lock lock(descriptor_data->mutex_); descriptor_data->descriptor_ = descriptor; descriptor_data->shutdown_ = false; + struct kevent events[2]; + BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, + EV_ADD | EV_CLEAR, 0, 0, descriptor_data); + BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, + EV_ADD | EV_CLEAR, 0, 0, descriptor_data); + if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1) + return errno; + return 0; } int kqueue_reactor::register_internal_descriptor( int op_type, socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op) @@ -145,29 +159,19 @@ int kqueue_reactor::register_internal_descriptor( mutex::scoped_lock lock(descriptor_data->mutex_); descriptor_data->descriptor_ = descriptor; descriptor_data->shutdown_ = false; descriptor_data->op_queue_[op_type].push(op); - struct kevent event; - switch (op_type) - { - case read_op: - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, - EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - break; - case write_op: - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE, - EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - break; - case except_op: - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, - EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data); - break; - } - ::kevent(kqueue_fd_, &event, 1, 0, 0, 0); + struct kevent events[2]; + BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, + EV_ADD | EV_CLEAR, 0, 0, descriptor_data); + BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, + EV_ADD | EV_CLEAR, 0, 0, descriptor_data); + if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1) + return errno; return 0; } void kqueue_reactor::move_descriptor(socket_type, kqueue_reactor::per_descriptor_data& target_descriptor_data, @@ -175,79 +179,57 @@ void kqueue_reactor::move_descriptor(socket_type, { target_descriptor_data = source_descriptor_data; source_descriptor_data = 0; } void kqueue_reactor::start_op(int op_type, socket_type descriptor, - kqueue_reactor::per_descriptor_data& descriptor_data, - reactor_op* op, bool allow_speculative) + kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op, + bool is_continuation, bool allow_speculative) { if (!descriptor_data) { op->ec_ = boost::asio::error::bad_descriptor; - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (descriptor_data->shutdown_) { - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } bool first = descriptor_data->op_queue_[op_type].empty(); if (first) { - if (allow_speculative) + if (allow_speculative + && (op_type != read_op + || descriptor_data->op_queue_[except_op].empty())) { - if (op_type != read_op || descriptor_data->op_queue_[except_op].empty()) + if (op->perform()) { - if (op->perform()) - { - descriptor_lock.unlock(); - io_service_.post_immediate_completion(op); - return; - } + descriptor_lock.unlock(); + io_service_.post_immediate_completion(op, is_continuation); + return; } } - } - - descriptor_data->op_queue_[op_type].push(op); - io_service_.work_started(); - - if (first) - { - struct kevent event; - switch (op_type) + else { - case read_op: - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, + struct kevent events[2]; + BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - break; - case write_op: - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE, + BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - break; - case except_op: - if (!descriptor_data->op_queue_[read_op].empty()) - return; // Already registered for read events. - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, - EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data); - break; - } - - if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1) - { - op->ec_ = boost::system::error_code(errno, - boost::asio::error::get_system_category()); - descriptor_data->op_queue_[op_type].pop(); - io_service_.post_deferred_completion(op); + ::kevent(kqueue_fd_, events, 2, 0, 0, 0); } } + + descriptor_data->op_queue_[op_type].push(op); + io_service_.work_started(); } void kqueue_reactor::cancel_ops(socket_type, kqueue_reactor::per_descriptor_data& descriptor_data) { if (!descriptor_data) @@ -364,18 +346,16 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops) struct kevent events[128]; int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout); // Dispatch the waiting events. for (int i = 0; i < num_events; ++i) { - int descriptor = events[i].ident; void* ptr = reinterpret_cast<void*>(events[i].udata); if (ptr == &interrupter_) { - // No need to reset the interrupter since we're leaving the descriptor - // in a ready-to-read state and relying on edge-triggered notifications. + interrupter_.reset(); } else { descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr); mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); @@ -394,13 +374,14 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops) if (j != except_op || events[i].flags & EV_OOBAND) { while (reactor_op* op = descriptor_data->op_queue_[j].front()) { if (events[i].flags & EV_ERROR) { - op->ec_ = boost::system::error_code(events[i].data, + op->ec_ = boost::system::error_code( + static_cast<int>(events[i].data), boost::asio::error::get_system_category()); descriptor_data->op_queue_[j].pop(); ops.push(op); } if (op->perform()) { @@ -410,64 +391,22 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops) else break; } } } } - - // Renew registration for event notifications. - struct kevent event; - switch (events[i].filter) - { - case EVFILT_READ: - if (!descriptor_data->op_queue_[read_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, - EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - else if (!descriptor_data->op_queue_[except_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ, - EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data); - else - continue; - break; - case EVFILT_WRITE: - if (!descriptor_data->op_queue_[write_op].empty()) - BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE, - EV_ADD | EV_CLEAR, 0, 0, descriptor_data); - else - continue; - break; - default: - break; - } - if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1) - { - boost::system::error_code error(errno, - boost::asio::error::get_system_category()); - for (int j = 0; j < max_ops; ++j) - { - while (reactor_op* op = descriptor_data->op_queue_[j].front()) - { - op->ec_ = error; - descriptor_data->op_queue_[j].pop(); - ops.push(op); - } - } - } } } lock.lock(); timer_queues_.get_ready_timers(ops); } void kqueue_reactor::interrupt() { - struct kevent event; - BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(), - EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, &interrupter_); - ::kevent(kqueue_fd_, &event, 1, 0, 0, 0); + interrupter_.interrupt(); } int kqueue_reactor::do_kqueue_create() { int fd = ::kqueue(); if (fd == -1) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp index 75a8d16..556c5a2 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp @@ -1,11 +1,11 @@ // // detail/impl/pipe_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP @@ -14,22 +14,24 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) +#if !defined(BOOST_ASIO_WINDOWS) #if !defined(__CYGWIN__) #if !defined(__SYMBIAN32__) #if !defined(BOOST_ASIO_HAS_EVENTFD) #include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <boost/asio/detail/pipe_select_interrupter.hpp> +#include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -87,22 +89,22 @@ void pipe_select_interrupter::recreate() open_descriptors(); } void pipe_select_interrupter::interrupt() { char byte = 0; - int result = ::write(write_descriptor_, &byte, 1); + signed_size_type result = ::write(write_descriptor_, &byte, 1); (void)result; } bool pipe_select_interrupter::reset() { for (;;) { char data[1024]; - int bytes_read = ::read(read_descriptor_, data, sizeof(data)); + signed_size_type bytes_read = ::read(read_descriptor_, data, sizeof(data)); if (bytes_read < 0 && errno == EINTR) continue; bool was_interrupted = (bytes_read > 0); while (bytes_read == sizeof(data)) bytes_read = ::read(read_descriptor_, data, sizeof(data)); return was_interrupted; @@ -115,9 +117,10 @@ bool pipe_select_interrupter::reset() #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_EVENTFD) #endif // !defined(__SYMBIAN32__) #endif // !defined(__CYGWIN__) -#endif // !defined(BOOST_WINDOWS) +#endif // !defined(BOOST_ASIO_WINDOWS) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp index 08eae05..acb0f57 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp @@ -1,11 +1,11 @@ // // detail/impl/posix_event.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP @@ -14,25 +14,26 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <boost/asio/detail/posix_event.hpp> #include <boost/asio/detail/throw_error.hpp> +#include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { posix_event::posix_event() - : signalled_(false) + : state_(0) { int error = ::pthread_cond_init(&cond_, 0); boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "event"); } @@ -40,9 +41,9 @@ posix_event::posix_event() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp index 94b9bf4..d815512 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp @@ -1,11 +1,11 @@ // // detail/impl/posix_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <boost/asio/detail/posix_mutex.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -40,9 +40,9 @@ posix_mutex::posix_mutex() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp index 0c52971..4b487d9 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp @@ -1,11 +1,11 @@ // // detail/impl/posix_thread.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <boost/asio/detail/posix_thread.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -68,9 +68,9 @@ void* boost_asio_detail_posix_thread_function(void* arg) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp index 5124c5f..65f9077 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp @@ -1,11 +1,11 @@ // // detail/impl/posix_tss_ptr.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <boost/asio/detail/posix_tss_ptr.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -40,9 +40,9 @@ void posix_tss_ptr_create(pthread_key_t& key) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp index dff0a82..abf4c6f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/reactive_descriptor_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP @@ -14,13 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) #include <boost/asio/error.hpp> #include <boost/asio/detail/reactive_descriptor_service.hpp> #include <boost/asio/detail/push_options.hpp> @@ -174,32 +176,35 @@ boost::system::error_code reactive_descriptor_service::cancel( ec = boost::system::error_code(); return ec; } void reactive_descriptor_service::start_op( reactive_descriptor_service::implementation_type& impl, - int op_type, reactor_op* op, bool is_non_blocking, bool noop) + int op_type, reactor_op* op, bool is_continuation, + bool is_non_blocking, bool noop) { if (!noop) { if ((impl.state_ & descriptor_ops::non_blocking) || descriptor_ops::set_internal_non_blocking( impl.descriptor_, impl.state_, true, op->ec_)) { reactor_.start_op(op_type, impl.descriptor_, - impl.reactor_data_, op, is_non_blocking); + impl.reactor_data_, op, is_continuation, is_non_blocking); return; } } - reactor_.post_immediate_completion(op); + reactor_.post_immediate_completion(op, is_continuation); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp index 0f530d7..b8c2f4a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/reactive_serial_port_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -16,13 +16,13 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_SERIAL_PORT) -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <cstring> #include <boost/asio/detail/reactive_serial_port_service.hpp> #include <boost/asio/detail/push_options.hpp> @@ -144,10 +144,10 @@ boost::system::error_code reactive_serial_port_service::do_get_option( } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp index 93277e0..c72871d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp @@ -1,11 +1,11 @@ // // detail/reactive_socket_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP @@ -14,13 +14,14 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_ASIO_HAS_IOCP) +#if !defined(BOOST_ASIO_HAS_IOCP) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <boost/asio/detail/reactive_socket_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -197,69 +198,72 @@ boost::system::error_code reactive_socket_service_base::do_assign( ec = boost::system::error_code(); return ec; } void reactive_socket_service_base::start_op( reactive_socket_service_base::base_implementation_type& impl, - int op_type, reactor_op* op, bool is_non_blocking, bool noop) + int op_type, reactor_op* op, bool is_continuation, + bool is_non_blocking, bool noop) { if (!noop) { if ((impl.state_ & socket_ops::non_blocking) || socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) { reactor_.start_op(op_type, impl.socket_, - impl.reactor_data_, op, is_non_blocking); + impl.reactor_data_, op, is_continuation, is_non_blocking); return; } } - reactor_.post_immediate_completion(op); + reactor_.post_immediate_completion(op, is_continuation); } void reactive_socket_service_base::start_accept_op( reactive_socket_service_base::base_implementation_type& impl, - reactor_op* op, bool peer_is_open) + reactor_op* op, bool is_continuation, bool peer_is_open) { if (!peer_is_open) - start_op(impl, reactor::read_op, op, true, false); + start_op(impl, reactor::read_op, op, true, is_continuation, false); else { op->ec_ = boost::asio::error::already_open; - reactor_.post_immediate_completion(op); + reactor_.post_immediate_completion(op, is_continuation); } } void reactive_socket_service_base::start_connect_op( reactive_socket_service_base::base_implementation_type& impl, - reactor_op* op, const socket_addr_type* addr, size_t addrlen) + reactor_op* op, bool is_continuation, + const socket_addr_type* addr, size_t addrlen) { if ((impl.state_ & socket_ops::non_blocking) || socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) { if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0) { if (op->ec_ == boost::asio::error::in_progress || op->ec_ == boost::asio::error::would_block) { op->ec_ = boost::system::error_code(); - reactor_.start_op(reactor::connect_op, - impl.socket_, impl.reactor_data_, op, false); + reactor_.start_op(reactor::connect_op, impl.socket_, + impl.reactor_data_, op, is_continuation, false); return; } } } - reactor_.post_immediate_completion(op); + reactor_.post_immediate_completion(op, is_continuation); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_IOCP) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp index 6a384e4..77b6c27 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp @@ -1,11 +1,11 @@ // // detail/impl/resolver_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP @@ -107,13 +107,13 @@ void resolver_service_base::cancel( } void resolver_service_base::start_resolve_op(operation* op) { start_work_thread(); io_service_impl_.work_started(); - work_io_service_impl_.post_immediate_completion(op); + work_io_service_impl_.post_immediate_completion(op, false); } void resolver_service_base::start_work_thread() { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (!work_thread_.get()) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp index 0d4097e..f2b79f7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp @@ -1,11 +1,11 @@ // // detail/impl/select_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP @@ -17,13 +17,14 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) \ || (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ - && !defined(BOOST_ASIO_HAS_KQUEUE)) + && !defined(BOOST_ASIO_HAS_KQUEUE) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -47,13 +48,13 @@ void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); io_service_.work_started(); if (earliest) @@ -79,9 +80,10 @@ std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue, #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) // || (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) - // && !defined(BOOST_ASIO_HAS_KQUEUE)) + // && !defined(BOOST_ASIO_HAS_KQUEUE) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp index d11904e..c8e04a2 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp @@ -1,11 +1,11 @@ // // detail/impl/select_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP @@ -17,13 +17,14 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) \ || (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ - && !defined(BOOST_ASIO_HAS_KQUEUE)) + && !defined(BOOST_ASIO_HAS_KQUEUE) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fd_set_adapter.hpp> #include <boost/asio/detail/select_reactor.hpp> #include <boost/asio/detail/signal_blocker.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -119,19 +120,20 @@ void select_reactor::move_descriptor(socket_type, select_reactor::per_descriptor_data&, select_reactor::per_descriptor_data&) { } void select_reactor::start_op(int op_type, socket_type descriptor, - select_reactor::per_descriptor_data&, reactor_op* op, bool) + select_reactor::per_descriptor_data&, reactor_op* op, + bool is_continuation, bool) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { - post_immediate_completion(op); + post_immediate_completion(op, is_continuation); return; } bool first = op_queue_[op_type].enqueue_operation(descriptor, op); io_service_.work_started(); if (first) @@ -177,27 +179,27 @@ void select_reactor::run(bool block, op_queue<operation>& ops) fd_sets_[read_op].set(interrupter_.read_descriptor()); socket_type max_fd = 0; bool have_work_to_do = !timer_queues_.all_empty(); for (int i = 0; i < max_select_ops; ++i) { have_work_to_do = have_work_to_do || !op_queue_[i].empty(); - op_queue_[i].get_descriptors(fd_sets_[i], ops); + fd_sets_[i].set(op_queue_[i], ops); if (fd_sets_[i].max_descriptor() > max_fd) max_fd = fd_sets_[i].max_descriptor(); } -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Connection operations on Windows use both except and write fd_sets. have_work_to_do = have_work_to_do || !op_queue_[connect_op].empty(); - op_queue_[connect_op].get_descriptors(fd_sets_[write_op], ops); + fd_sets_[write_op].set(op_queue_[connect_op], ops); if (fd_sets_[write_op].max_descriptor() > max_fd) max_fd = fd_sets_[write_op].max_descriptor(); - op_queue_[connect_op].get_descriptors(fd_sets_[except_op], ops); + fd_sets_[except_op].set(op_queue_[connect_op], ops); if (fd_sets_[except_op].max_descriptor() > max_fd) max_fd = fd_sets_[except_op].max_descriptor(); -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // We can return immediately if there's no work to do and the reactor is // not supposed to block. if (!block && !have_work_to_do) return; @@ -221,24 +223,22 @@ void select_reactor::run(bool block, op_queue<operation>& ops) lock.lock(); // Dispatch all ready operations. if (retval > 0) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Connection operations on Windows use both except and write fd_sets. - op_queue_[connect_op].perform_operations_for_descriptors( - fd_sets_[except_op], ops); - op_queue_[connect_op].perform_operations_for_descriptors( - fd_sets_[write_op], ops); -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) + fd_sets_[except_op].perform(op_queue_[connect_op], ops); + fd_sets_[write_op].perform(op_queue_[connect_op], ops); +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. for (int i = max_select_ops - 1; i >= 0; --i) - op_queue_[i].perform_operations_for_descriptors(fd_sets_[i], ops); + fd_sets_[i].perform(op_queue_[i], ops); } timer_queues_.get_ready_timers(ops); } void select_reactor::interrupt() { @@ -307,8 +307,9 @@ void select_reactor::cancel_ops_unlocked(socket_type descriptor, #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) // || (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) // && !defined(BOOST_ASIO_HAS_KQUEUE)) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp index eef25ac..1f71f08 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp @@ -1,11 +1,11 @@ // // detail/impl/service_registry.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp index 6715010..adfcaa0 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp @@ -1,11 +1,11 @@ // // detail/impl/service_registry.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP @@ -13,15 +13,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/throw_exception.hpp> #include <vector> #include <boost/asio/detail/service_registry.hpp> +#include <boost/asio/detail/throw_exception.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -143,22 +143,22 @@ boost::asio::io_service::service* service_registry::do_use_service( void service_registry::do_add_service( const boost::asio::io_service::service::key& key, boost::asio::io_service::service* new_service) { if (&owner_ != &new_service->get_io_service()) - boost::throw_exception(invalid_service_owner()); + boost::asio::detail::throw_exception(invalid_service_owner()); boost::asio::detail::mutex::scoped_lock lock(mutex_); // Check if there is an existing service object with the given key. boost::asio::io_service::service* service = first_service_; while (service) { if (keys_match(service->key_, key)) - boost::throw_exception(service_already_exists()); + boost::asio::detail::throw_exception(service_already_exists()); service = service->next_; } // Take ownership of the service object. new_service->key_ = key; new_service->next_ = first_service_; diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp index 0b57007..21be62f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/signal_set_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP @@ -54,31 +54,39 @@ signal_state* get_signal_state() { static signal_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0, { 0 } }; return &state; } -void asio_signal_handler(int signal_number) +void boost_asio_signal_handler(int signal_number) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) \ + || defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + || defined(__CYGWIN__) signal_set_service::deliver_signal(signal_number); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) + // || defined(BOOST_ASIO_WINDOWS_RUNTIME) + // || defined(__CYGWIN__) int saved_errno = errno; signal_state* state = get_signal_state(); - int result = ::write(state->write_descriptor_, + signed_size_type result = ::write(state->write_descriptor_, &signal_number, sizeof(signal_number)); (void)result; errno = saved_errno; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) + // || defined(BOOST_ASIO_WINDOWS_RUNTIME) + // || defined(__CYGWIN__) #if defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION) - ::signal(signal_number, asio_signal_handler); + ::signal(signal_number, boost_asio_signal_handler); #endif // defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION) } -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) class signal_set_service::pipe_read_op : public reactor_op { public: pipe_read_op() : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete) { @@ -102,28 +110,38 @@ public: std::size_t /*bytes_transferred*/) { pipe_read_op* o(static_cast<pipe_read_op*>(base)); delete o; } }; -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) signal_set_service::signal_set_service( boost::asio::io_service& io_service) : io_service_(boost::asio::use_service<io_service_impl>(io_service)), -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) reactor_(boost::asio::use_service<reactor>(io_service)), -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) next_(0), prev_(0) { get_signal_state()->mutex_.init(); -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) reactor_.init_task(); -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) for (int i = 0; i < max_signal_number; ++i) registrations_[i] = 0; add_service(this); } @@ -152,45 +170,61 @@ void signal_set_service::shutdown_service() io_service_.abandon_operations(ops); } void signal_set_service::fork_service( boost::asio::io_service::fork_event fork_ev) { -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); switch (fork_ev) { case boost::asio::io_service::fork_prepare: - reactor_.deregister_internal_descriptor( - state->read_descriptor_, reactor_data_); - state->fork_prepared_ = true; + { + int read_descriptor = state->read_descriptor_; + state->fork_prepared_ = true; + lock.unlock(); + reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_); + } break; case boost::asio::io_service::fork_parent: - state->fork_prepared_ = false; - reactor_.register_internal_descriptor(reactor::read_op, - state->read_descriptor_, reactor_data_, new pipe_read_op); + if (state->fork_prepared_) + { + int read_descriptor = state->read_descriptor_; + state->fork_prepared_ = false; + lock.unlock(); + reactor_.register_internal_descriptor(reactor::read_op, + read_descriptor, reactor_data_, new pipe_read_op); + } break; case boost::asio::io_service::fork_child: if (state->fork_prepared_) { boost::asio::detail::signal_blocker blocker; close_descriptors(); open_descriptors(); + int read_descriptor = state->read_descriptor_; state->fork_prepared_ = false; + lock.unlock(); + reactor_.register_internal_descriptor(reactor::read_op, + read_descriptor, reactor_data_, new pipe_read_op); } - reactor_.register_internal_descriptor(reactor::read_op, - state->read_descriptor_, reactor_data_, new pipe_read_op); break; default: break; } -#else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#else // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) (void)fork_ev; -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) } void signal_set_service::construct( signal_set_service::implementation_type& impl) { impl.signals_ = 0; @@ -206,13 +240,13 @@ void signal_set_service::destroy( boost::system::error_code signal_set_service::add( signal_set_service::implementation_type& impl, int signal_number, boost::system::error_code& ec) { // Check that the signal number is valid. - if (signal_number < 0 || signal_number > max_signal_number) + if (signal_number < 0 || signal_number >= max_signal_number) { ec = boost::asio::error::invalid_argument; return ec; } signal_state* state = get_signal_state(); @@ -237,25 +271,25 @@ boost::system::error_code signal_set_service::add( if (state->registration_count_[signal_number] == 0) { # if defined(BOOST_ASIO_HAS_SIGACTION) using namespace std; // For memset. struct sigaction sa; memset(&sa, 0, sizeof(sa)); - sa.sa_handler = asio_signal_handler; + sa.sa_handler = boost_asio_signal_handler; sigfillset(&sa.sa_mask); if (::sigaction(signal_number, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) - if (::signal(signal_number, asio_signal_handler) == SIG_ERR) + if (::signal(signal_number, boost_asio_signal_handler) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { -# if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; -# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); -# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) delete new_registration; return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION) @@ -280,13 +314,13 @@ boost::system::error_code signal_set_service::add( boost::system::error_code signal_set_service::remove( signal_set_service::implementation_type& impl, int signal_number, boost::system::error_code& ec) { // Check that the signal number is valid. - if (signal_number < 0 || signal_number > max_signal_number) + if (signal_number < 0 || signal_number >= max_signal_number) { ec = boost::asio::error::invalid_argument; return ec; } signal_state* state = get_signal_state(); @@ -314,18 +348,18 @@ boost::system::error_code signal_set_service::remove( sa.sa_handler = SIG_DFL; if (::sigaction(signal_number, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) if (::signal(signal_number, SIG_DFL) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { -# if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; -# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); -# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION) // Remove the registration from the set. @@ -368,18 +402,18 @@ boost::system::error_code signal_set_service::clear( sa.sa_handler = SIG_DFL; if (::sigaction(reg->signal_number_, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) if (::signal(reg->signal_number_, SIG_DFL) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { -# if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; -# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); -# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION) // Remove the registration from the registration table. @@ -463,66 +497,81 @@ void signal_set_service::deliver_signal(int signal_number) void signal_set_service::add_service(signal_set_service* service) { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // If this is the first service to be created, open a new pipe. if (state->service_list_ == 0) open_descriptors(); -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // Insert service into linked list of all services. service->next_ = state->service_list_; service->prev_ = 0; if (state->service_list_) state->service_list_->prev_ = service; state->service_list_ = service; -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) // Register for pipe readiness notifications. + int read_descriptor = state->read_descriptor_; + lock.unlock(); service->reactor_.register_internal_descriptor(reactor::read_op, - state->read_descriptor_, service->reactor_data_, new pipe_read_op); -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) + read_descriptor, service->reactor_data_, new pipe_read_op); +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) } void signal_set_service::remove_service(signal_set_service* service) { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); if (service->next_ || service->prev_ || state->service_list_ == service) { -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) // Disable the pipe readiness notifications. + int read_descriptor = state->read_descriptor_; + lock.unlock(); service->reactor_.deregister_descriptor( - state->read_descriptor_, service->reactor_data_, false); -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) + read_descriptor, service->reactor_data_, false); + lock.lock(); +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) // Remove service from linked list of all services. if (state->service_list_ == service) state->service_list_ = service->next_; if (service->prev_) service->prev_->next_ = service->next_; if (service->next_) service->next_->prev_= service->prev_; service->next_ = 0; service->prev_ = 0; -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // If this is the last service to be removed, close the pipe. if (state->service_list_ == 0) close_descriptors(); -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) } } void signal_set_service::open_descriptors() { -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) signal_state* state = get_signal_state(); int pipe_fds[2]; if (::pipe(pipe_fds) == 0) { state->read_descriptor_ = pipe_fds[0]; @@ -539,28 +588,34 @@ void signal_set_service::open_descriptors() else { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "signal_set_service pipe"); } -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) } void signal_set_service::close_descriptors() { -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) signal_state* state = get_signal_state(); if (state->read_descriptor_ != -1) ::close(state->read_descriptor_); state->read_descriptor_ = -1; if (state->write_descriptor_ != -1) ::close(state->write_descriptor_); state->write_descriptor_ = -1; -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) } void signal_set_service::start_wait_op( signal_set_service::implementation_type& impl, signal_op* op) { io_service_.work_started(); @@ -571,12 +626,13 @@ void signal_set_service::start_wait_op( registration* reg = impl.signals_; while (reg) { if (reg->undelivered_ > 0) { --reg->undelivered_; + op->signal_number_ = reg->signal_number_; io_service_.post_deferred_completion(op); return; } reg = reg->next_in_set_; } diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp index 16e9536..f2c9a11 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp @@ -1,11 +1,11 @@ // // detail/impl/socket_ops.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_OPS_IPP @@ -13,55 +13,75 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/assert.hpp> -#include <boost/detail/workaround.hpp> + #include <cctype> #include <cstdio> #include <cstdlib> #include <cstring> #include <cerrno> #include <new> +#include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +# include <codecvt> +# include <locale> +# include <string> +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) \ + || defined(__MACH__) && defined(__APPLE__) +# if defined(BOOST_ASIO_HAS_PTHREADS) +# include <pthread.h> +# endif // defined(BOOST_ASIO_HAS_PTHREADS) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) + // || defined(__MACH__) && defined(__APPLE__) + #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace socket_ops { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) struct msghdr { int msg_namelen; }; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #if defined(__hpux) // HP-UX doesn't declare these functions extern "C", so they are declared again // here to avoid linker errors about undefined symbols. extern "C" char* if_indextoname(unsigned int, char*); extern "C" unsigned int if_nametoindex(const char*); #endif // defined(__hpux) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + inline void clear_last_error() { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) WSASetLastError(0); #else errno = 0; #endif } +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + template <typename ReturnType> inline ReturnType error_wrapper(ReturnType return_value, boost::system::error_code& ec) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ec = boost::system::error_code(WSAGetLastError(), boost::asio::error::get_system_category()); #else ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); #endif @@ -290,49 +310,49 @@ int close(socket_type s, state_type& state, boost::system::error_code ignored_ec; socket_ops::setsockopt(s, state, SOL_SOCKET, SO_LINGER, &opt, sizeof(opt), ignored_ec); } clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) result = error_wrapper(::closesocket(s), ec); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) result = error_wrapper(::close(s), ec); -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) if (result != 0 && (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again)) { // According to UNIX Network Programming Vol. 1, it is possible for // close() to fail with EWOULDBLOCK under certain circumstances. What // isn't clear is the state of the descriptor after this error. The one // current OS where this behaviour is seen, Windows, says that the socket // remains open. Therefore we'll put the descriptor back into blocking // mode and have another attempt at closing it. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ioctl_arg_type arg = 0; ::ioctlsocket(s, FIONBIO, &arg); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # if defined(__SYMBIAN32__) int flags = ::fcntl(s, F_GETFL, 0); if (flags >= 0) ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK); # else // defined(__SYMBIAN32__) ioctl_arg_type arg = 0; ::ioctl(s, FIONBIO, &arg); # endif // defined(__SYMBIAN32__) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) state &= ~non_blocking; clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) result = error_wrapper(::closesocket(s), ec); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) result = error_wrapper(::close(s), ec); -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } } if (result == 0) ec = boost::system::error_code(); return result; @@ -345,13 +365,13 @@ bool set_user_non_blocking(socket_type s, { ec = boost::asio::error::bad_descriptor; return false; } clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ioctl_arg_type arg = (value ? 1 : 0); int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec); #elif defined(__SYMBIAN32__) int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec); if (result >= 0) { @@ -398,13 +418,13 @@ bool set_internal_non_blocking(socket_type s, // caller figure out whether to update the user-set non-blocking flag. ec = boost::asio::error::invalid_argument; return false; } clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) ioctl_arg_type arg = (value ? 1 : 0); int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec); #elif defined(__SYMBIAN32__) int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec); if (result >= 0) { @@ -498,14 +518,63 @@ void sync_connect(socket_type s, const socket_addr_type* addr, // Return the result of the connect operation. ec = boost::system::error_code(connect_error, boost::asio::error::get_system_category()); } +#if defined(BOOST_ASIO_HAS_IOCP) + +void complete_iocp_connect(socket_type s, boost::system::error_code& ec) +{ + if (!ec) + { + // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname + // and getpeername will work on the connected socket. + socket_ops::state_type state = 0; + const int so_update_connect_context = 0x7010; + socket_ops::setsockopt(s, state, SOL_SOCKET, + so_update_connect_context, 0, 0, ec); + } +} + +#endif // defined(BOOST_ASIO_HAS_IOCP) + bool non_blocking_connect(socket_type s, boost::system::error_code& ec) { + // Check if the connect operation has finished. This is required since we may + // get spurious readiness notifications from the reactor. +#if defined(BOOST_ASIO_WINDOWS) \ + || defined(__CYGWIN__) \ + || defined(__SYMBIAN32__) + fd_set write_fds; + FD_ZERO(&write_fds); + FD_SET(s, &write_fds); + fd_set except_fds; + FD_ZERO(&except_fds); + FD_SET(s, &except_fds); + timeval zero_timeout; + zero_timeout.tv_sec = 0; + zero_timeout.tv_usec = 0; + int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout); +#else // defined(BOOST_ASIO_WINDOWS) + // || defined(__CYGWIN__) + // || defined(__SYMBIAN32__) + pollfd fds; + fds.fd = s; + fds.events = POLLOUT; + fds.revents = 0; + int ready = ::poll(&fds, 1, 0); +#endif // defined(BOOST_ASIO_WINDOWS) + // || defined(__CYGWIN__) + // || defined(__SYMBIAN32__) + if (ready == 0) + { + // The asynchronous connect operation is still in progress. + return false; + } + // Get the error code from the connect operation. int connect_error = 0; size_t connect_error_len = sizeof(connect_error); if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec) == 0) { @@ -521,13 +590,13 @@ bool non_blocking_connect(socket_type s, boost::system::error_code& ec) return true; } int socketpair(int af, int type, int protocol, socket_type sv[2], boost::system::error_code& ec) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) (void)(af); (void)(type); (void)(protocol); (void)(sv); ec = boost::asio::error::operation_not_supported; return socket_error_retval; @@ -547,17 +616,17 @@ bool sockatmark(socket_type s, boost::system::error_code& ec) ec = boost::asio::error::bad_descriptor; return false; } #if defined(SIOCATMARK) ioctl_arg_type value = 0; -# if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::ioctlsocket(s, SIOCATMARK, &value), ec); -# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::ioctl(s, SIOCATMARK, &value), ec); -# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) if (result == 0) ec = boost::system::error_code(); # if defined(ENOTTY) if (ec.value() == ENOTTY) ec = boost::asio::error::not_socket; # endif // defined(ENOTTY) @@ -576,17 +645,17 @@ size_t available(socket_type s, boost::system::error_code& ec) { ec = boost::asio::error::bad_descriptor; return 0; } ioctl_arg_type value = 0; -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::ioctlsocket(s, FIONREAD, &value), ec); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::ioctl(s, FIONREAD, &value), ec); -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) if (result == 0) ec = boost::system::error_code(); #if defined(ENOTTY) if (ec.value() == ENOTTY) ec = boost::asio::error::not_socket; #endif // defined(ENOTTY) @@ -617,38 +686,38 @@ inline void init_buf_iov_base(void*& base, void* addr) template <typename T> inline void init_buf_iov_base(T& base, void* addr) { base = static_cast<T>(addr); } -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef WSABUF buf; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef iovec buf; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) void init_buf(buf& b, void* data, size_t size) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) b.buf = static_cast<char*>(data); b.len = static_cast<u_long>(size); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) init_buf_iov_base(b.iov_base, data); b.iov_len = size; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } void init_buf(buf& b, const void* data, size_t size) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) b.buf = static_cast<char*>(const_cast<void*>(data)); b.len = static_cast<u_long>(size); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) init_buf_iov_base(b.iov_base, const_cast<void*>(data)); b.iov_len = size; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr) { name = addr; } @@ -667,17 +736,17 @@ inline void init_msghdr_msg_name(T& name, socket_addr_type* addr) template <typename T> inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr) { name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr)); } -int recv(socket_type s, buf* bufs, size_t count, int flags, - boost::system::error_code& ec) +signed_size_type recv(socket_type s, buf* bufs, size_t count, + int flags, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Receive some data. DWORD recv_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int result = error_wrapper(::WSARecv(s, bufs, recv_buf_count, &bytes_transferred, &recv_flags, 0, 0), ec); @@ -686,21 +755,21 @@ int recv(socket_type s, buf* bufs, size_t count, int flags, else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec = boost::system::error_code(); return bytes_transferred; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = bufs; - msg.msg_iovlen = count; - int result = error_wrapper(::recvmsg(s, &msg, flags), ec); + msg.msg_iovlen = static_cast<int>(count); + signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec); if (result >= 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } size_t sync_recv(socket_type s, state_type state, buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec) { if (s == invalid_socket) @@ -717,13 +786,13 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs, } // Read some data. for (;;) { // Try to complete the operation without blocking. - int bytes = socket_ops::recv(s, bufs, count, flags, ec); + signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec); // Check if operation succeeded. if (bytes > 0) return bytes; // Check for EOF. @@ -779,13 +848,13 @@ bool non_blocking_recv(socket_type s, buf* bufs, size_t count, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. - int bytes = socket_ops::recv(s, bufs, count, flags, ec); + signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec); // Check for end of stream. if (is_stream && bytes == 0) { ec = boost::asio::error::eof; return true; @@ -812,18 +881,18 @@ bool non_blocking_recv(socket_type s, return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) -int recvfrom(socket_type s, buf* bufs, size_t count, int flags, - socket_addr_type* addr, std::size_t* addrlen, +signed_size_type recvfrom(socket_type s, buf* bufs, size_t count, + int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Receive some data. DWORD recv_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int tmp_addrlen = (int)*addrlen; int result = error_wrapper(::WSARecvFrom(s, bufs, recv_buf_count, @@ -834,24 +903,24 @@ int recvfrom(socket_type s, buf* bufs, size_t count, int flags, else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec = boost::system::error_code(); return bytes_transferred; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) msghdr msg = msghdr(); init_msghdr_msg_name(msg.msg_name, addr); - msg.msg_namelen = *addrlen; + msg.msg_namelen = static_cast<int>(*addrlen); msg.msg_iov = bufs; - msg.msg_iovlen = count; - int result = error_wrapper(::recvmsg(s, &msg, flags), ec); + msg.msg_iovlen = static_cast<int>(count); + signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec); *addrlen = msg.msg_namelen; if (result >= 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { @@ -862,13 +931,14 @@ size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, } // Read some data. for (;;) { // Try to complete the operation without blocking. - int bytes = socket_ops::recvfrom(s, bufs, count, flags, addr, addrlen, ec); + signed_size_type bytes = socket_ops::recvfrom( + s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. @@ -910,13 +980,14 @@ bool non_blocking_recvfrom(socket_type s, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. - int bytes = socket_ops::recvfrom(s, bufs, count, flags, addr, addrlen, ec); + signed_size_type bytes = socket_ops::recvfrom( + s, bufs, count, flags, addr, addrlen, ec); // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. @@ -936,33 +1007,33 @@ bool non_blocking_recvfrom(socket_type s, return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) -int recvmsg(socket_type s, buf* bufs, size_t count, +signed_size_type recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) out_flags = 0; return socket_ops::recv(s, bufs, count, in_flags, ec); -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = bufs; - msg.msg_iovlen = count; - int result = error_wrapper(::recvmsg(s, &msg, in_flags), ec); + msg.msg_iovlen = static_cast<int>(count); + signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec); if (result >= 0) { ec = boost::system::error_code(); out_flags = msg.msg_flags; } else out_flags = 0; return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } size_t sync_recvmsg(socket_type s, state_type state, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec) { @@ -973,13 +1044,14 @@ size_t sync_recvmsg(socket_type s, state_type state, } // Read some data. for (;;) { // Try to complete the operation without blocking. - int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec); + signed_size_type bytes = socket_ops::recvmsg( + s, bufs, count, in_flags, out_flags, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. @@ -1020,13 +1092,14 @@ bool non_blocking_recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. - int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec); + signed_size_type bytes = socket_ops::recvmsg( + s, bufs, count, in_flags, out_flags, ec); // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. @@ -1046,17 +1119,17 @@ bool non_blocking_recvmsg(socket_type s, return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) -int send(socket_type s, const buf* bufs, size_t count, int flags, - boost::system::error_code& ec) +signed_size_type send(socket_type s, const buf* bufs, size_t count, + int flags, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Send the data. DWORD send_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD send_flags = flags; int result = error_wrapper(::WSASend(s, const_cast<buf*>(bufs), send_buf_count, &bytes_transferred, send_flags, 0, 0), ec); @@ -1065,24 +1138,24 @@ int send(socket_type s, const buf* bufs, size_t count, int flags, else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec = boost::system::error_code(); return bytes_transferred; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = const_cast<buf*>(bufs); - msg.msg_iovlen = count; + msg.msg_iovlen = static_cast<int>(count); #if defined(__linux__) flags |= MSG_NOSIGNAL; #endif // defined(__linux__) - int result = error_wrapper(::sendmsg(s, &msg, flags), ec); + signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec); if (result >= 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } size_t sync_send(socket_type s, state_type state, const buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec) { if (s == invalid_socket) @@ -1099,13 +1172,13 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs, } // Read some data. for (;;) { // Try to complete the operation without blocking. - int bytes = socket_ops::send(s, bufs, count, flags, ec); + signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. @@ -1146,13 +1219,13 @@ bool non_blocking_send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. - int bytes = socket_ops::send(s, bufs, count, flags, ec); + signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec); // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. @@ -1172,18 +1245,18 @@ bool non_blocking_send(socket_type s, return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) -int sendto(socket_type s, const buf* bufs, size_t count, int flags, - const socket_addr_type* addr, std::size_t addrlen, +signed_size_type sendto(socket_type s, const buf* bufs, size_t count, + int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Send the data. DWORD send_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; int result = error_wrapper(::WSASendTo(s, const_cast<buf*>(bufs), send_buf_count, &bytes_transferred, flags, addr, static_cast<int>(addrlen), 0, 0), ec); @@ -1192,26 +1265,26 @@ int sendto(socket_type s, const buf* bufs, size_t count, int flags, else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec = boost::system::error_code(); return bytes_transferred; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) msghdr msg = msghdr(); init_msghdr_msg_name(msg.msg_name, addr); - msg.msg_namelen = addrlen; + msg.msg_namelen = static_cast<int>(addrlen); msg.msg_iov = const_cast<buf*>(bufs); - msg.msg_iovlen = count; + msg.msg_iovlen = static_cast<int>(count); #if defined(__linux__) flags |= MSG_NOSIGNAL; #endif // defined(__linux__) - int result = error_wrapper(::sendmsg(s, &msg, flags), ec); + signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec); if (result >= 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } size_t sync_sendto(socket_type s, state_type state, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { @@ -1222,13 +1295,14 @@ size_t sync_sendto(socket_type s, state_type state, const buf* bufs, } // Write some data. for (;;) { // Try to complete the operation without blocking. - int bytes = socket_ops::sendto(s, bufs, count, flags, addr, addrlen, ec); + signed_size_type bytes = socket_ops::sendto( + s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. @@ -1250,13 +1324,14 @@ bool non_blocking_sendto(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. - int bytes = socket_ops::sendto(s, bufs, count, flags, addr, addrlen, ec); + signed_size_type bytes = socket_ops::sendto( + s, bufs, count, flags, addr, addrlen, ec); // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. @@ -1280,19 +1355,19 @@ bool non_blocking_sendto(socket_type s, #endif // !defined(BOOST_ASIO_HAS_IOCP) socket_type socket(int af, int type, int protocol, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) socket_type s = error_wrapper(::WSASocket(af, type, protocol, 0, 0, WSA_FLAG_OVERLAPPED), ec); if (s == invalid_socket) return s; - if (af == AF_INET6) + if (af == BOOST_ASIO_OS_DEF(AF_INET6)) { // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to // false. This will only succeed on Windows Vista and later versions of // Windows, where a dual-stack IPv4/v6 implementation is available. DWORD optval = 0; ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, @@ -1478,13 +1553,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname, } return result; } } ec = boost::asio::error::fault; return socket_error_retval; -#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) clear_last_error(); int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen, s, level, optname, optval, optlen), ec); if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD)) { @@ -1496,13 +1571,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname, *static_cast<DWORD*>(optval) = 1; ec = boost::system::error_code(); } if (result == 0) ec = boost::system::error_code(); return result; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) clear_last_error(); int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen, s, level, optname, optval, optlen), ec); #if defined(__linux__) if (result == 0 && level == SOL_SOCKET && *optlen == sizeof(int) && (optname == SO_SNDBUF || optname == SO_RCVBUF)) @@ -1515,13 +1590,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname, *static_cast<int*>(optval) /= 2; } #endif // defined(__linux__) if (result == 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } template <typename SockLenType> inline int call_getpeername(SockLenType msghdr::*, socket_type s, socket_addr_type* addr, std::size_t* addrlen) { @@ -1537,13 +1612,13 @@ int getpeername(socket_type s, socket_addr_type* addr, if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) if (cached) { // Check if socket is still connected. DWORD connect_time = 0; size_t connect_time_len = sizeof(connect_time); if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME, @@ -1558,15 +1633,15 @@ int getpeername(socket_type s, socket_addr_type* addr, } // The cached value is still valid. ec = boost::system::error_code(); return 0; } -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) (void)cached; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) clear_last_error(); int result = error_wrapper(call_getpeername( &msghdr::msg_namelen, s, addr, addrlen), ec); if (result == 0) ec = boost::system::error_code(); @@ -1607,13 +1682,13 @@ int ioctl(socket_type s, state_type& state, int cmd, { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec); #elif defined(__MACH__) && defined(__APPLE__) \ || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) int result = error_wrapper(::ioctl(s, static_cast<unsigned int>(cmd), arg), ec); #else @@ -1648,13 +1723,13 @@ int ioctl(socket_type s, state_type& state, int cmd, } int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) if (!readfds && !writefds && !exceptfds && timeout) { DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000; if (milliseconds == 0) milliseconds = 1; // Force context switch. ::Sleep(milliseconds); @@ -1668,13 +1743,13 @@ int select(int nfds, fd_set* readfds, fd_set* writefds, // reactor, meaning increased CPU usage, when waiting for the earliest // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight // spin we'll use a minimum timeout of 1 millisecond. if (timeout && timeout->tv_sec == 0 && timeout->tv_usec > 0 && timeout->tv_usec < 1000) timeout->tv_usec = 1000; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #if defined(__hpux) && defined(__SELECT) timespec ts; ts.tv_sec = timeout ? timeout->tv_sec : 0; ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0; return error_wrapper(::pselect(nfds, readfds, @@ -1693,35 +1768,35 @@ int poll_read(socket_type s, state_type state, boost::system::error_code& ec) if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } -#if defined(BOOST_WINDOWS) \ +#if defined(BOOST_ASIO_WINDOWS) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) fd_set fds; FD_ZERO(&fds); FD_SET(s, &fds); timeval zero_timeout; zero_timeout.tv_sec = 0; zero_timeout.tv_usec = 0; timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0; clear_last_error(); - int result = error_wrapper(::select(s, &fds, 0, 0, timeout), ec); -#else // defined(BOOST_WINDOWS) + int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec); +#else // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLIN; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : -1; clear_last_error(); int result = error_wrapper(::poll(&fds, 1, timeout), ec); -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) if (result == 0) ec = (state & user_set_non_blocking) ? boost::asio::error::would_block : boost::system::error_code(); else if (result > 0) @@ -1734,35 +1809,35 @@ int poll_write(socket_type s, state_type state, boost::system::error_code& ec) if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } -#if defined(BOOST_WINDOWS) \ +#if defined(BOOST_ASIO_WINDOWS) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) fd_set fds; FD_ZERO(&fds); FD_SET(s, &fds); timeval zero_timeout; zero_timeout.tv_sec = 0; zero_timeout.tv_usec = 0; timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0; clear_last_error(); - int result = error_wrapper(::select(s, 0, &fds, 0, timeout), ec); -#else // defined(BOOST_WINDOWS) + int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec); +#else // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLOUT; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : -1; clear_last_error(); int result = error_wrapper(::poll(&fds, 1, timeout), ec); -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) if (result == 0) ec = (state & user_set_non_blocking) ? boost::asio::error::would_block : boost::system::error_code(); else if (result > 0) @@ -1775,51 +1850,89 @@ int poll_connect(socket_type s, boost::system::error_code& ec) if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } -#if defined(BOOST_WINDOWS) \ +#if defined(BOOST_ASIO_WINDOWS) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) fd_set write_fds; FD_ZERO(&write_fds); FD_SET(s, &write_fds); fd_set except_fds; FD_ZERO(&except_fds); FD_SET(s, &except_fds); clear_last_error(); - int result = error_wrapper(::select(s, 0, &write_fds, &except_fds, 0), ec); + int result = error_wrapper(::select( + s + 1, 0, &write_fds, &except_fds, 0), ec); if (result >= 0) ec = boost::system::error_code(); return result; -#else // defined(BOOST_WINDOWS) +#else // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLOUT; fds.revents = 0; clear_last_error(); int result = error_wrapper(::poll(&fds, 1, -1), ec); if (result >= 0) ec = boost::system::error_code(); return result; -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) } +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + const char* inet_ntop(int af, const void* src, char* dest, size_t length, unsigned long scope_id, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + using namespace std; // For sprintf. + const unsigned char* bytes = static_cast<const unsigned char*>(src); + if (af == BOOST_ASIO_OS_DEF(AF_INET)) + { + sprintf_s(dest, length, "%u.%u.%u.%u", + bytes[0], bytes[1], bytes[2], bytes[3]); + return dest; + } + else if (af == BOOST_ASIO_OS_DEF(AF_INET6)) + { + size_t n = 0, b = 0, z = 0; + while (n < length && b < 16) + { + if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0) + { + do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0); + n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z; + } + else + { + n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "", + (static_cast<u_long_type>(bytes[b]) << 8) | bytes[b + 1]); + b += 2; + } + } + if (scope_id) + n += sprintf_s(dest + n, length - n, "%%%lu", scope_id); + return dest; + } + else + { + ec = boost::asio::error::address_family_not_supported; + return 0; + } +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) using namespace std; // For memcpy. - if (af != AF_INET && af != AF_INET6) + if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6)) { ec = boost::asio::error::address_family_not_supported; return 0; } union @@ -1827,31 +1940,31 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length, socket_addr_type base; sockaddr_storage_type storage; sockaddr_in4_type v4; sockaddr_in6_type v6; } address; DWORD address_length; - if (af == AF_INET) + if (af == BOOST_ASIO_OS_DEF(AF_INET)) { address_length = sizeof(sockaddr_in4_type); - address.v4.sin_family = AF_INET; + address.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET); address.v4.sin_port = 0; memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type)); } else // AF_INET6 { address_length = sizeof(sockaddr_in6_type); - address.v6.sin6_family = AF_INET6; + address.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6); address.v6.sin6_port = 0; address.v6.sin6_flowinfo = 0; address.v6.sin6_scope_id = scope_id; memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type)); } DWORD string_length = static_cast<DWORD>(length); -#if defined(BOOST_NO_ANSI_APIS) +#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800)) LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR)); int result = error_wrapper(::WSAAddressToStringW(&address.base, address_length, 0, string_buffer, &string_length), ec); ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0); #else int result = error_wrapper(::WSAAddressToStringA( @@ -1864,39 +1977,187 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length, // Windows may not set an error code on failure. else if (result == socket_error_retval && !ec) ec = boost::asio::error::invalid_argument; return result == socket_error_retval ? 0 : dest; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) - const char* result = error_wrapper(::inet_ntop(af, src, dest, length), ec); +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) + const char* result = error_wrapper(::inet_ntop( + af, src, dest, static_cast<int>(length)), ec); if (result == 0 && !ec) ec = boost::asio::error::invalid_argument; - if (result != 0 && af == AF_INET6 && scope_id != 0) + if (result != 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id != 0) { using namespace std; // For strcat and sprintf. char if_name[IF_NAMESIZE + 1] = "%"; const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src); bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); - if (!is_link_local || if_indextoname(scope_id, if_name + 1) == 0) + bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff) + && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02)); + if ((!is_link_local && !is_multicast_link_local) + || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0) sprintf(if_name + 1, "%lu", scope_id); strcat(dest, if_name); } return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } int inet_pton(int af, const char* src, void* dest, unsigned long* scope_id, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + using namespace std; // For sscanf. + unsigned char* bytes = static_cast<unsigned char*>(dest); + if (af == BOOST_ASIO_OS_DEF(AF_INET)) + { + unsigned int b0, b1, b2, b3; + if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4) + { + ec = boost::asio::error::invalid_argument; + return -1; + } + if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255) + { + ec = boost::asio::error::invalid_argument; + return -1; + } + bytes[0] = static_cast<unsigned char>(b0); + bytes[1] = static_cast<unsigned char>(b1); + bytes[2] = static_cast<unsigned char>(b2); + bytes[3] = static_cast<unsigned char>(b3); + ec = boost::system::error_code(); + return 1; + } + else if (af == BOOST_ASIO_OS_DEF(AF_INET6)) + { + unsigned char* bytes = static_cast<unsigned char*>(dest); + std::memset(bytes, 0, 16); + unsigned char back_bytes[16] = { 0 }; + int num_front_bytes = 0, num_back_bytes = 0; + const char* p = src; + + enum { fword, fcolon, bword, scope, done } state = fword; + unsigned long current_word = 0; + while (state != done) + { + if (current_word > 0xFFFF) + { + ec = boost::asio::error::invalid_argument; + return -1; + } + + switch (state) + { + case fword: + if (*p >= '0' && *p <= '9') + current_word = current_word * 16 + *p++ - '0'; + else if (*p >= 'a' && *p <= 'f') + current_word = current_word * 16 + *p++ - 'a' + 10; + else if (*p >= 'A' && *p <= 'F') + current_word = current_word * 16 + *p++ - 'A' + 10; + else + { + if (num_front_bytes == 16) + { + ec = boost::asio::error::invalid_argument; + return -1; + } + + bytes[num_front_bytes++] = (current_word >> 8) & 0xFF; + bytes[num_front_bytes++] = current_word & 0xFF; + current_word = 0; + + if (*p == ':') + state = fcolon, ++p; + else if (*p == '%') + state = scope, ++p; + else if (*p == 0) + state = done; + else + { + ec = boost::asio::error::invalid_argument; + return -1; + } + } + break; + + case fcolon: + if (*p == ':') + state = bword, ++p; + else + state = fword; + break; + + case bword: + if (*p >= '0' && *p <= '9') + current_word = current_word * 16 + *p++ - '0'; + else if (*p >= 'a' && *p <= 'f') + current_word = current_word * 16 + *p++ - 'a' + 10; + else if (*p >= 'A' && *p <= 'F') + current_word = current_word * 16 + *p++ - 'A' + 10; + else + { + if (num_front_bytes + num_back_bytes == 16) + { + ec = boost::asio::error::invalid_argument; + return -1; + } + + back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF; + back_bytes[num_back_bytes++] = current_word & 0xFF; + current_word = 0; + + if (*p == ':') + state = bword, ++p; + else if (*p == '%') + state = scope, ++p; + else if (*p == 0) + state = done; + else + { + ec = boost::asio::error::invalid_argument; + return -1; + } + } + break; + + case scope: + if (*p >= '0' && *p <= '9') + current_word = current_word * 10 + *p++ - '0'; + else if (*p == 0) + *scope_id = current_word, state = done; + else + { + ec = boost::asio::error::invalid_argument; + return -1; + } + break; + + default: + break; + } + } + + for (int i = 0; i < num_back_bytes; ++i) + bytes[16 - num_back_bytes + i] = back_bytes[i]; + + ec = boost::system::error_code(); + return 1; + } + else + { + ec = boost::asio::error::address_family_not_supported; + return -1; + } +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) using namespace std; // For memcpy and strcmp. - if (af != AF_INET && af != AF_INET6) + if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6)) { ec = boost::asio::error::address_family_not_supported; return -1; } union @@ -1904,24 +2165,24 @@ int inet_pton(int af, const char* src, void* dest, socket_addr_type base; sockaddr_storage_type storage; sockaddr_in4_type v4; sockaddr_in6_type v6; } address; int address_length = sizeof(sockaddr_storage_type); -#if defined(BOOST_NO_ANSI_APIS) +#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800)) int num_wide_chars = strlen(src) + 1; LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR)); ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars); int result = error_wrapper(::WSAStringToAddressW( wide_buffer, af, 0, &address.base, &address_length), ec); #else int result = error_wrapper(::WSAStringToAddressA( const_cast<char*>(src), af, 0, &address.base, &address_length), ec); #endif - if (af == AF_INET) + if (af == BOOST_ASIO_OS_DEF(AF_INET)) { if (result != socket_error_retval) { memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type)); ec = boost::system::error_code(); } @@ -1947,48 +2208,82 @@ int inet_pton(int af, const char* src, void* dest, ec = boost::asio::error::invalid_argument; if (result != socket_error_retval) ec = boost::system::error_code(); return result == socket_error_retval ? -1 : 1; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) int result = error_wrapper(::inet_pton(af, src, dest), ec); if (result <= 0 && !ec) ec = boost::asio::error::invalid_argument; - if (result > 0 && af == AF_INET6 && scope_id) + if (result > 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id) { using namespace std; // For strchr and atoi. *scope_id = 0; if (const char* if_name = strchr(src, '%')) { in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest); bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); - if (is_link_local) + bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff) + && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02)); + if (is_link_local || is_multicast_link_local) *scope_id = if_nametoindex(if_name + 1); if (*scope_id == 0) *scope_id = atoi(if_name + 1); } } return result; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) } int gethostname(char* name, int namelen, boost::system::error_code& ec) { clear_last_error(); +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + try + { + using namespace Windows::Foundation::Collections; + using namespace Windows::Networking; + using namespace Windows::Networking::Connectivity; + IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames(); + for (unsigned i = 0; i < hostnames->Size; ++i) + { + HostName^ hostname = hostnames->GetAt(i); + if (hostname->Type == HostNameType::DomainName) + { + std::wstring_convert<std::codecvt_utf8<wchar_t>> converter; + std::string raw_name = converter.to_bytes(hostname->RawName->Data()); + if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen)) + { + strcpy_s(name, namelen, raw_name.c_str()); + return 0; + } + } + } + return -1; + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + return -1; + } +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) int result = error_wrapper(::gethostname(name, namelen), ec); -#if defined(BOOST_WINDOWS) +# if defined(BOOST_ASIO_WINDOWS) if (result == 0) ec = boost::system::error_code(); -#endif +# endif // defined(BOOST_ASIO_WINDOWS) return result; +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) \ - || defined(__MACH__) && defined(__APPLE__) +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if !defined(BOOST_ASIO_HAS_GETADDRINFO) // The following functions are only needed for emulation of getaddrinfo and // getnameinfo. inline boost::system::error_code translate_netdb_error(int error) { @@ -2002,22 +2297,22 @@ inline boost::system::error_code translate_netdb_error(int error) return boost::asio::error::host_not_found_try_again; case NO_RECOVERY: return boost::asio::error::no_recovery; case NO_DATA: return boost::asio::error::no_data; default: - BOOST_ASSERT(false); + BOOST_ASIO_ASSERT(false); return boost::asio::error::invalid_argument; } } inline hostent* gethostbyaddr(const char* addr, int length, int af, hostent* result, char* buffer, int buflength, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) (void)(buffer); (void)(buflength); hostent* retval = error_wrapper(::gethostbyaddr(addr, length, af), ec); if (!retval) return 0; ec = boost::system::error_code(); @@ -2054,30 +2349,30 @@ inline hostent* gethostbyaddr(const char* addr, int length, int af, } inline hostent* gethostbyname(const char* name, int af, struct hostent* result, char* buffer, int buflength, int ai_flags, boost::system::error_code& ec) { clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) (void)(buffer); (void)(buflength); (void)(ai_flags); - if (af != AF_INET) + if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } hostent* retval = error_wrapper(::gethostbyname(name), ec); if (!retval) return 0; ec = boost::system::error_code(); *result = *retval; return result; #elif defined(__sun) || defined(__QNX__) (void)(ai_flags); - if (af != AF_INET) + if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } int error = 0; hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer, @@ -2096,13 +2391,13 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result, if (!retval) return 0; *result = *retval; return retval; #else (void)(ai_flags); - if (af != AF_INET) + if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } hostent* retval = 0; int error = 0; @@ -2141,83 +2436,83 @@ inline int gai_nsearch(const char* host, { if (hints->ai_flags & AI_PASSIVE) { // No host and AI_PASSIVE implies wildcard bind. switch (hints->ai_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = "0.0.0.0"; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = "0::0"; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; - case AF_UNSPEC: + case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = "0::0"; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = "0.0.0.0"; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } else { // No host and not AI_PASSIVE means connect to local host. switch (hints->ai_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = "localhost"; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = "localhost"; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; - case AF_UNSPEC: + case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = "localhost"; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = "localhost"; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } } else { // Host is specified. switch (hints->ai_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = host; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = host; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; - case AF_UNSPEC: + case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = host; - search[search_count].family = AF_INET6; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = host; - search[search_count].family = AF_INET; + search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } @@ -2239,18 +2534,18 @@ inline void gai_free(void* p) ::operator delete(p); } inline void gai_strcpy(char* target, const char* source, std::size_t max_size) { using namespace std; -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_HAS_SECURE_RTL) strcpy_s(target, max_size, source); -#else +#else // defined(BOOST_ASIO_HAS_SECURE_RTL) *target = 0; strncat(target, source, max_size); -#endif +#endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } enum { gai_clone_flag = 1 << 30 }; inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints, const void* addr, int family) @@ -2271,29 +2566,29 @@ inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints, ai->ai_flags |= gai_clone_flag; ai->ai_protocol = hints->ai_protocol; ai->ai_family = family; switch (ai->ai_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): { sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>(); if (sinptr == 0) return EAI_MEMORY; - sinptr->sin_family = AF_INET; + sinptr->sin_family = BOOST_ASIO_OS_DEF(AF_INET); memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type)); ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr); ai->ai_addrlen = sizeof(sockaddr_in4_type); break; } - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): { sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>(); if (sin6ptr == 0) return EAI_MEMORY; - sin6ptr->sin6_family = AF_INET6; + sin6ptr->sin6_family = BOOST_ASIO_OS_DEF(AF_INET6); memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type)); ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr); ai->ai_addrlen = sizeof(sockaddr_in6_type); break; } default: @@ -2349,21 +2644,21 @@ inline int gai_port(addrinfo_type* aihead, int port, int socktype) } ai->ai_socktype = socktype; switch (ai->ai_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): { sockaddr_in4_type* sinptr = reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr); sinptr->sin_port = port; ++num_found; break; } - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): { sockaddr_in6_type* sin6ptr = reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr); sin6ptr->sin6_port = port; ++num_found; break; @@ -2466,16 +2761,16 @@ inline int gai_echeck(const char* host, const char* service, if (service == 0 || service[0] == '\0') return EAI_NONAME; // Check combination of family and socket type. switch (family) { - case AF_UNSPEC: + case BOOST_ASIO_OS_DEF(AF_UNSPEC): break; - case AF_INET: - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET): + case BOOST_ASIO_OS_DEF(AF_INET6): if (service != 0 && service[0] != '\0') if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM) return EAI_SOCKTYPE; break; default: return EAI_FAMILY; @@ -2504,24 +2799,24 @@ inline int getaddrinfo_emulation(const char* host, const char* service, addrinfo_type* aihead = 0; addrinfo_type** ainext = &aihead; char* canon = 0; // Supply default hints if not specified by caller. addrinfo_type hints = addrinfo_type(); - hints.ai_family = AF_UNSPEC; + hints.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC); if (hintsp) hints = *hintsp; // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED // and AI_ALL flags. #if defined(AI_V4MAPPED) - if (hints.ai_family != AF_INET6) + if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) hints.ai_flags &= ~AI_V4MAPPED; #endif #if defined(AI_ALL) - if (hints.ai_family != AF_INET6) + if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) hints.ai_flags &= ~AI_ALL; #endif // Basic error checking. int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family, hints.ai_socktype, hints.ai_protocol); @@ -2535,46 +2830,51 @@ inline int getaddrinfo_emulation(const char* host, const char* service, int search_count = gai_nsearch(host, &hints, search); for (gai_search* sptr = search; sptr < search + search_count; ++sptr) { // Check for IPv4 dotted decimal string. in4_addr_type inaddr; boost::system::error_code ec; - if (socket_ops::inet_pton(AF_INET, sptr->host, &inaddr, 0, ec) == 1) + if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET), + sptr->host, &inaddr, 0, ec) == 1) { - if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET) + if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) + && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET)) { freeaddrinfo_emulation(aihead); gai_free(canon); return EAI_FAMILY; } - if (sptr->family == AF_INET) + if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET)) { - rc = gai_aistruct(&ainext, &hints, &inaddr, AF_INET); + rc = gai_aistruct(&ainext, &hints, &inaddr, BOOST_ASIO_OS_DEF(AF_INET)); if (rc != 0) { freeaddrinfo_emulation(aihead); gai_free(canon); return rc; } } continue; } // Check for IPv6 hex string. in6_addr_type in6addr; - if (socket_ops::inet_pton(AF_INET6, sptr->host, &in6addr, 0, ec) == 1) + if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6), + sptr->host, &in6addr, 0, ec) == 1) { - if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET6) + if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) + && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) { freeaddrinfo_emulation(aihead); gai_free(canon); return EAI_FAMILY; } - if (sptr->family == AF_INET6) + if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET6)) { - rc = gai_aistruct(&ainext, &hints, &in6addr, AF_INET6); + rc = gai_aistruct(&ainext, &hints, &in6addr, + BOOST_ASIO_OS_DEF(AF_INET6)); if (rc != 0) { freeaddrinfo_emulation(aihead); gai_free(canon); return rc; } @@ -2605,13 +2905,14 @@ inline int getaddrinfo_emulation(const char* host, const char* service, if (ec == boost::asio::error::no_data) return EAI_NONAME; return EAI_NONAME; } // Check for address family mismatch if one was specified. - if (hints.ai_family != AF_UNSPEC && hints.ai_family != hptr->h_addrtype) + if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) + && hints.ai_family != hptr->h_addrtype) { freeaddrinfo_emulation(aihead); gai_free(canon); socket_ops::freehostent(hptr); return EAI_FAMILY; } @@ -2701,23 +3002,23 @@ inline boost::system::error_code getnameinfo_emulation( const char* addr; size_t addr_len; unsigned short port; switch (sa->sa_family) { - case AF_INET: + case BOOST_ASIO_OS_DEF(AF_INET): if (salen != sizeof(sockaddr_in4_type)) { return ec = boost::asio::error::invalid_argument; } addr = reinterpret_cast<const char*>( &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr); addr_len = sizeof(in4_addr_type); port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port; break; - case AF_INET6: + case BOOST_ASIO_OS_DEF(AF_INET6): if (salen != sizeof(sockaddr_in6_type)) { return ec = boost::asio::error::invalid_argument; } addr = reinterpret_cast<const char*>( &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr); @@ -2778,57 +3079,52 @@ inline boost::system::error_code getnameinfo_emulation( if (flags & NI_NUMERICSERV) { if (servlen < 6) { return ec = boost::asio::error::no_buffer_space; } -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf_s(serv, servlen, "%u", ntohs(port)); -#else +#else // defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf(serv, "%u", ntohs(port)); -#endif +#endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } else { -#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) \ - && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; ::pthread_mutex_lock(&mutex); -#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) - // && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0); if (sptr && sptr->s_name && sptr->s_name[0] != '\0') { gai_strcpy(serv, sptr->s_name, servlen); } else { if (servlen < 6) { return ec = boost::asio::error::no_buffer_space; } -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf_s(serv, servlen, "%u", ntohs(port)); -#else +#else // defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf(serv, "%u", ntohs(port)); -#endif +#endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } -#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) \ - && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) ::pthread_mutex_unlock(&mutex); -#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) - // && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) } } ec = boost::system::error_code(); return ec; } -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) - // || defined(__MACH__) && defined(__APPLE__) +#endif // !defined(BOOST_ASIO_HAS_GETADDRINFO) inline boost::system::error_code translate_addrinfo_error(int error) { switch (error) { case 0: @@ -2853,13 +3149,13 @@ inline boost::system::error_code translate_addrinfo_error(int error) return boost::asio::error::host_not_found; case EAI_SERVICE: return boost::asio::error::service_not_found; case EAI_SOCKTYPE: return boost::asio::error::socket_type_not_supported; default: // Possibly the non-portable EAI_SYSTEM. -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) return boost::system::error_code( WSAGetLastError(), boost::asio::error::get_system_category()); #else return boost::system::error_code( errno, boost::asio::error::get_system_category()); #endif @@ -2870,14 +3166,14 @@ boost::system::error_code getaddrinfo(const char* host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec) { host = (host && *host) ? host : 0; service = (service && *service) ? service : 0; clear_last_error(); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) -# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. int error = ::getaddrinfo(host, service, &hints, result); return ec = translate_addrinfo_error(error); # else // Building for Windows 2000 or earlier. typedef int (WSAAPI *gai_t)(const char*, @@ -2890,13 +3186,13 @@ boost::system::error_code getaddrinfo(const char* host, return ec = translate_addrinfo_error(error); } } int error = getaddrinfo_emulation(host, service, &hints, result); return ec = translate_addrinfo_error(error); # endif -#elif defined(__MACH__) && defined(__APPLE__) +#elif !defined(BOOST_ASIO_HAS_GETADDRINFO) int error = getaddrinfo_emulation(host, service, &hints, result); return ec = translate_addrinfo_error(error); #else int error = ::getaddrinfo(host, service, &hints, result); return ec = translate_addrinfo_error(error); #endif @@ -2913,14 +3209,14 @@ boost::system::error_code background_getaddrinfo( socket_ops::getaddrinfo(host, service, hints, result, ec); return ec; } void freeaddrinfo(addrinfo_type* ai) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) -# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. ::freeaddrinfo(ai); # else // Building for Windows 2000 or earlier. typedef int (WSAAPI *fai_t)(addrinfo_type*); if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) @@ -2930,25 +3226,25 @@ void freeaddrinfo(addrinfo_type* ai) fai(ai); return; } } freeaddrinfo_emulation(ai); # endif -#elif defined(__MACH__) && defined(__APPLE__) +#elif !defined(BOOST_ASIO_HAS_GETADDRINFO) freeaddrinfo_emulation(ai); #else ::freeaddrinfo(ai); #endif } boost::system::error_code getnameinfo(const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int flags, boost::system::error_code& ec) { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) -# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) +# if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. clear_last_error(); int error = ::getnameinfo(addr, static_cast<socklen_t>(addrlen), host, static_cast<DWORD>(hostlen), serv, static_cast<DWORD>(servlen), flags); return ec = translate_addrinfo_error(error); @@ -2968,13 +3264,13 @@ boost::system::error_code getnameinfo(const socket_addr_type* addr, } } clear_last_error(); return getnameinfo_emulation(addr, addrlen, host, hostlen, serv, servlen, flags, ec); # endif -#elif defined(__MACH__) && defined(__APPLE__) +#elif !defined(BOOST_ASIO_HAS_GETADDRINFO) using namespace std; // For memcpy. sockaddr_storage_type tmp_addr; memcpy(&tmp_addr, addr, addrlen); tmp_addr.ss_len = addrlen; addr = reinterpret_cast<socket_addr_type*>(&tmp_addr); clear_last_error(); @@ -3030,30 +3326,66 @@ boost::system::error_code background_getnameinfo( } } return ec; } +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + u_long_type network_to_host_long(u_long_type value) { +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + unsigned char* value_p = reinterpret_cast<unsigned char*>(&value); + u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24) + | (static_cast<u_long_type>(value_p[1]) << 16) + | (static_cast<u_long_type>(value_p[2]) << 8) + | static_cast<u_long_type>(value_p[3]); + return result; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return ntohl(value); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_long_type host_to_network_long(u_long_type value) { +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + u_long_type result; + unsigned char* result_p = reinterpret_cast<unsigned char*>(&result); + result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF); + result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF); + result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF); + result_p[3] = static_cast<unsigned char>(value & 0xFF); + return result; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return htonl(value); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_short_type network_to_host_short(u_short_type value) { +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + unsigned char* value_p = reinterpret_cast<unsigned char*>(&value); + u_short_type result = (static_cast<u_long_type>(value_p[0]) << 8) + | static_cast<u_long_type>(value_p[1]); + return result; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return ntohs(value); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_short_type host_to_network_short(u_short_type value) { +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + u_long_type result; + unsigned char* result_p = reinterpret_cast<unsigned char*>(&result); + result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF); + result_p[1] = static_cast<unsigned char>(value & 0xFF); + return result; +#else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return htons(value); +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } } // namespace socket_ops } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp index 6005f12..e2dedc7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp @@ -1,11 +1,11 @@ // // detail/impl/socket_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP @@ -14,13 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) \ +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_WINDOWS) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) #include <cstdlib> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -54,26 +56,26 @@ void socket_select_interrupter::open_descriptors() using namespace std; // For memset. sockaddr_in4_type addr; std::size_t addr_len = sizeof(addr); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; - addr.sin_addr.s_addr = inet_addr("127.0.0.1"); + addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK); addr.sin_port = 0; if (socket_ops::bind(acceptor.get(), (const socket_addr_type*)&addr, addr_len, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); if (socket_ops::getsockname(acceptor.get(), (socket_addr_type*)&addr, &addr_len, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); // Some broken firewalls on Windows will intermittently cause getsockname to // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We // explicitly specify the target address here to work around this problem. - addr.sin_addr.s_addr = inet_addr("127.0.0.1"); + addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK); if (socket_ops::listen(acceptor.get(), SOMAXCONN, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); socket_holder client(socket_ops::socket( @@ -163,11 +165,13 @@ bool socket_select_interrupter::reset() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #endif // BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp index 7581852..17227f9 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp @@ -1,23 +1,24 @@ // // detail/impl/strand_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP #define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/call_stack.hpp> #include <boost/asio/detail/completion_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> @@ -43,31 +44,31 @@ struct strand_service::on_dispatch_exit impl_->mutex_.lock(); impl_->ready_queue_.push(impl_->waiting_queue_); bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty(); impl_->mutex_.unlock(); if (more_handlers) - io_service_->post_immediate_completion(impl_); + io_service_->post_immediate_completion(impl_, false); } }; template <typename Handler> void strand_service::dispatch(strand_service::implementation_type& impl, - Handler handler) + Handler& handler) { // If we are already in the strand then the handler can run immediately. if (call_stack<strand_impl>::contains(impl)) { fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(handler, handler); return; } // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "dispatch")); @@ -89,24 +90,27 @@ void strand_service::dispatch(strand_service::implementation_type& impl, } } // Request the io_service to invoke the given handler and return immediately. template <typename Handler> void strand_service::post(strand_service::implementation_type& impl, - Handler handler) + Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "post")); - do_post(impl, p.p); + do_post(impl, p.p, is_continuation); p.v = p.p = 0; } } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp index 1912d80..9af0128 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/strand_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP @@ -35,13 +35,13 @@ struct strand_service::on_do_complete_exit impl_->mutex_.lock(); impl_->ready_queue_.push(impl_->waiting_queue_); bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty(); impl_->mutex_.unlock(); if (more_handlers) - owner_->post_private_immediate_completion(impl_); + owner_->post_immediate_completion(impl_, true); } }; strand_service::strand_service(boost::asio::io_service& io_service) : boost::asio::detail::service_base<strand_service>(io_service), io_service_(boost::asio::use_service<io_service_impl>(io_service)), @@ -82,12 +82,18 @@ void strand_service::construct(strand_service::implementation_type& impl) if (!implementations_[index].get()) implementations_[index].reset(new strand_impl); impl = implementations_[index].get(); } +bool strand_service::running_in_this_thread( + const implementation_type& impl) const +{ + return call_stack<strand_impl>::contains(impl) != 0; +} + bool strand_service::do_dispatch(implementation_type& impl, operation* op) { // If we are running inside the io_service, and no other handler already // holds the strand lock, then the handler can run immediately. bool can_dispatch = io_service_.can_dispatch(); impl->mutex_.lock(); @@ -109,19 +115,20 @@ bool strand_service::do_dispatch(implementation_type& impl, operation* op) { // The handler is acquiring the strand lock and so is responsible for // scheduling the strand. impl->locked_ = true; impl->mutex_.unlock(); impl->ready_queue_.push(op); - io_service_.post_immediate_completion(impl); + io_service_.post_immediate_completion(impl, false); } return false; } -void strand_service::do_post(implementation_type& impl, operation* op) +void strand_service::do_post(implementation_type& impl, + operation* op, bool is_continuation) { impl->mutex_.lock(); if (impl->locked_) { // Some other handler already holds the strand lock. Enqueue for later. impl->waiting_queue_.push(op); @@ -131,13 +138,13 @@ void strand_service::do_post(implementation_type& impl, operation* op) { // The handler is acquiring the strand lock and so is responsible for // scheduling the strand. impl->locked_ = true; impl->mutex_.unlock(); impl->ready_queue_.push(op); - io_service_.post_immediate_completion(impl); + io_service_.post_immediate_completion(impl, is_continuation); } } void strand_service::do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& ec, std::size_t /*bytes_transferred*/) { diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp index 2cc7b7e..4312de7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp @@ -1,71 +1,76 @@ // // detail/impl/task_io_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP #define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/completion_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler> -void task_io_service::dispatch(Handler handler) +void task_io_service::dispatch(Handler& handler) { if (thread_call_stack::contains(this)) { fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(handler, handler); } else { // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch")); - post_non_private_immediate_completion(p.p); + do_dispatch(p.p); p.v = p.p = 0; } } template <typename Handler> -void task_io_service::post(Handler handler) +void task_io_service::post(Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post")); - post_immediate_completion(p.p); + post_immediate_completion(p.p, is_continuation); p.v = p.p = 0; } } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp index 674df63..e58e11e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/task_io_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP @@ -16,31 +16,24 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if !defined(BOOST_ASIO_HAS_IOCP) -#include <boost/limits.hpp> #include <boost/asio/detail/event.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/task_io_service.hpp> +#include <boost/asio/detail/task_io_service_thread_info.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { -struct task_io_service::thread_info -{ - event* wakeup_event; - op_queue<operation> private_op_queue; - long private_outstanding_work; - thread_info* next; -}; - struct task_io_service::task_cleanup { ~task_cleanup() { if (this_thread_->private_outstanding_work > 0) { @@ -76,19 +69,19 @@ struct task_io_service::work_cleanup else if (this_thread_->private_outstanding_work < 1) { task_io_service_->work_finished(); } this_thread_->private_outstanding_work = 0; -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_THREADS) if (!this_thread_->private_op_queue.empty()) { lock_->lock(); task_io_service_->op_queue_.push(this_thread_->private_op_queue); } -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_THREADS) } task_io_service* task_io_service_; mutex::scoped_lock* lock_; thread_info* this_thread_; }; @@ -99,14 +92,13 @@ task_io_service::task_io_service( one_thread_(concurrency_hint == 1), mutex_(), task_(0), task_interrupted_(true), outstanding_work_(0), stopped_(false), - shutdown_(false), - first_idle_thread_(0) + shutdown_(false) { BOOST_ASIO_HANDLER_TRACKING_INIT; } void task_io_service::shutdown_service() { @@ -145,16 +137,13 @@ std::size_t task_io_service::run(boost::system::error_code& ec) { stop(); return 0; } thread_info this_thread; - event wakeup_event; - this_thread.wakeup_event = &wakeup_event; this_thread.private_outstanding_work = 0; - this_thread.next = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); std::size_t n = 0; for (; do_run_one(lock, this_thread, ec); lock.lock()) @@ -170,16 +159,13 @@ std::size_t task_io_service::run_one(boost::system::error_code& ec) { stop(); return 0; } thread_info this_thread; - event wakeup_event; - this_thread.wakeup_event = &wakeup_event; this_thread.private_outstanding_work = 0; - this_thread.next = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); return do_run_one(lock, this_thread, ec); } @@ -191,27 +177,25 @@ std::size_t task_io_service::poll(boost::system::error_code& ec) { stop(); return 0; } thread_info this_thread; - this_thread.wakeup_event = 0; this_thread.private_outstanding_work = 0; - this_thread.next = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_THREADS) // We want to support nested calls to poll() and poll_one(), so any handlers // that are already on a thread-private queue need to be put on to the main // queue now. if (one_thread_) if (thread_info* outer_thread_info = ctx.next_by_key()) op_queue_.push(outer_thread_info->private_op_queue); -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_THREADS) std::size_t n = 0; for (; do_poll_one(lock, this_thread, ec); lock.lock()) if (n != (std::numeric_limits<std::size_t>::max)()) ++n; return n; @@ -224,27 +208,25 @@ std::size_t task_io_service::poll_one(boost::system::error_code& ec) { stop(); return 0; } thread_info this_thread; - this_thread.wakeup_event = 0; this_thread.private_outstanding_work = 0; - this_thread.next = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_THREADS) // We want to support nested calls to poll() and poll_one(), so any handlers // that are already on a thread-private queue need to be put on to the main // queue now. if (one_thread_) if (thread_info* outer_thread_info = ctx.next_by_key()) op_queue_.push(outer_thread_info->private_op_queue); -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_THREADS) return do_poll_one(lock, this_thread, ec); } void task_io_service::stop() { @@ -261,105 +243,79 @@ bool task_io_service::stopped() const void task_io_service::reset() { mutex::scoped_lock lock(mutex_); stopped_ = false; } -void task_io_service::post_immediate_completion(task_io_service::operation* op) +void task_io_service::post_immediate_completion( + task_io_service::operation* op, bool is_continuation) { -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) - if (one_thread_) +#if defined(BOOST_ASIO_HAS_THREADS) + if (one_thread_ || is_continuation) { if (thread_info* this_thread = thread_call_stack::contains(this)) { ++this_thread->private_outstanding_work; this_thread->private_op_queue.push(op); return; } } -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#else // defined(BOOST_ASIO_HAS_THREADS) + (void)is_continuation; +#endif // defined(BOOST_ASIO_HAS_THREADS) work_started(); mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void task_io_service::post_deferred_completion(task_io_service::operation* op) { -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_) { if (thread_info* this_thread = thread_call_stack::contains(this)) { this_thread->private_op_queue.push(op); return; } } -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_THREADS) mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void task_io_service::post_deferred_completions( op_queue<task_io_service::operation>& ops) { if (!ops.empty()) { -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_) { if (thread_info* this_thread = thread_call_stack::contains(this)) { this_thread->private_op_queue.push(ops); return; } } -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_THREADS) mutex::scoped_lock lock(mutex_); op_queue_.push(ops); wake_one_thread_and_unlock(lock); } } -void task_io_service::post_private_immediate_completion( - task_io_service::operation* op) -{ - work_started(); - post_private_deferred_completion(op); -} - -void task_io_service::post_private_deferred_completion( - task_io_service::operation* op) -{ -#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) - if (thread_info* this_thread = thread_call_stack::contains(this)) - { - this_thread->private_op_queue.push(op); - return; - } -#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) - - mutex::scoped_lock lock(mutex_); - op_queue_.push(op); - wake_one_thread_and_unlock(lock); -} - -void task_io_service::post_non_private_immediate_completion( +void task_io_service::do_dispatch( task_io_service::operation* op) { work_started(); - post_non_private_deferred_completion(op); -} - -void task_io_service::post_non_private_deferred_completion( - task_io_service::operation* op) -{ mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void task_io_service::abandon_operations( @@ -384,16 +340,13 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock, if (o == &task_operation_) { task_interrupted_ = more_handlers; if (more_handlers && !one_thread_) - { - if (!wake_one_idle_thread_and_unlock(lock)) - lock.unlock(); - } + wakeup_event_.unlock_and_signal_one(lock); else lock.unlock(); task_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; @@ -420,17 +373,14 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock, return 1; } } else { - // Nothing to run right now, so just wait for work to do. - this_thread.next = first_idle_thread_; - first_idle_thread_ = &this_thread; - this_thread.wakeup_event->clear(lock); - this_thread.wakeup_event->wait(lock); + wakeup_event_.clear(lock); + wakeup_event_.wait(lock); } } return 0; } @@ -456,13 +406,16 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock, // as soon as possible. task_->run(false, this_thread.private_op_queue); } o = op_queue_.front(); if (o == &task_operation_) + { + wakeup_event_.maybe_unlock_and_signal_one(lock); return 0; + } } if (o == 0) return 0; op_queue_.pop(); @@ -486,46 +439,25 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock, } void task_io_service::stop_all_threads( mutex::scoped_lock& lock) { stopped_ = true; - - while (first_idle_thread_) - { - thread_info* idle_thread = first_idle_thread_; - first_idle_thread_ = idle_thread->next; - idle_thread->next = 0; - idle_thread->wakeup_event->signal(lock); - } + wakeup_event_.signal_all(lock); if (!task_interrupted_ && task_) { task_interrupted_ = true; task_->interrupt(); } } -bool task_io_service::wake_one_idle_thread_and_unlock( - mutex::scoped_lock& lock) -{ - if (first_idle_thread_) - { - thread_info* idle_thread = first_idle_thread_; - first_idle_thread_ = idle_thread->next; - idle_thread->next = 0; - idle_thread->wakeup_event->signal_and_unlock(lock); - return true; - } - return false; -} - void task_io_service::wake_one_thread_and_unlock( mutex::scoped_lock& lock) { - if (!wake_one_idle_thread_and_unlock(lock)) + if (!wakeup_event_.maybe_unlock_and_signal_one(lock)) { if (!task_interrupted_ && task_) { task_interrupted_ = true; task_->interrupt(); } diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp index dbe6112..5f6ed39 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp @@ -1,11 +1,11 @@ // // detail/impl/throw_error.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_THROW_ERROR_IPP @@ -13,32 +13,32 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/throw_exception.hpp> #include <boost/asio/detail/throw_error.hpp> +#include <boost/asio/detail/throw_exception.hpp> #include <boost/system/system_error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void do_throw_error(const boost::system::error_code& err) { boost::system::system_error e(err); - boost::throw_exception(e); + boost::asio::detail::throw_exception(e); } void do_throw_error(const boost::system::error_code& err, const char* location) { boost::system::system_error e(err, location); - boost::throw_exception(e); + boost::asio::detail::throw_exception(e); } } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp index c72d885..3b16def 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp @@ -1,11 +1,11 @@ // // detail/impl/timer_queue_ptime.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP @@ -17,12 +17,14 @@ #include <boost/asio/detail/config.hpp> #include <boost/asio/detail/timer_queue_ptime.hpp> #include <boost/asio/detail/push_options.hpp> +#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + namespace boost { namespace asio { namespace detail { timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue() { @@ -74,9 +76,11 @@ std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer( } } // namespace detail } // namespace asio } // namespace boost +#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp index 7f9a662..19b770b 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp @@ -1,11 +1,11 @@ // // detail/impl/timer_queue_set.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp index 252242c..a004c09 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp @@ -1,11 +1,11 @@ // // detail/win_event.ipp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_EVENT_IPP @@ -14,39 +14,56 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_event.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_event::win_event() - : event_(::CreateEvent(0, true, false, 0)) + : state_(0) { - if (!event_) + events_[0] = ::CreateEvent(0, true, false, 0); + if (!events_[0]) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "event"); } + + events_[1] = ::CreateEvent(0, false, false, 0); + if (!events_[1]) + { + DWORD last_error = ::GetLastError(); + ::CloseHandle(events_[0]); + boost::system::error_code ec(last_error, + boost::asio::error::get_system_category()); + boost::asio::detail::throw_error(ec, "event"); + } +} + +win_event::~win_event() +{ + ::CloseHandle(events_[0]); + ::CloseHandle(events_[1]); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp index ecd45c0..04a6791 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_iocp_handle_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -43,13 +43,14 @@ public: hEvent = ::CreateEvent(0, TRUE, FALSE, 0); if (hEvent) { // As documented in GetQueuedCompletionStatus, setting the low order // bit of this event prevents our synchronous writes from being treated // as completion port events. - *reinterpret_cast<DWORD_PTR*>(&hEvent) |= 1; + DWORD_PTR tmp = reinterpret_cast<DWORD_PTR>(hEvent); + hEvent = reinterpret_cast<HANDLE>(tmp | 1); } else { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); @@ -290,13 +291,13 @@ boost::system::error_code win_iocp_handle_service::cancel( } return ec; } size_t win_iocp_handle_service::do_write( - win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset, + win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; @@ -346,13 +347,13 @@ size_t win_iocp_handle_service::do_write( ec = boost::system::error_code(); return bytes_transferred; } void win_iocp_handle_service::start_write_op( - win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset, + win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) @@ -384,13 +385,13 @@ void win_iocp_handle_service::start_write_op( iocp_service_.on_pending(op); } } } size_t win_iocp_handle_service::do_read( - win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset, + win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; @@ -446,21 +447,21 @@ size_t win_iocp_handle_service::do_read( } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } - return 0; + return (last_error == ERROR_MORE_DATA) ? bytes_transferred : 0; } ec = boost::system::error_code(); return bytes_transferred; } void win_iocp_handle_service::start_read_op( - win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset, + win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp index 871f6fa..201a17e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp @@ -1,11 +1,11 @@ // // detail/impl/win_iocp_io_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP @@ -16,60 +16,61 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/completion_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler> -void win_iocp_io_service::dispatch(Handler handler) +void win_iocp_io_service::dispatch(Handler& handler) { - if (call_stack<win_iocp_io_service>::contains(this)) + if (thread_call_stack::contains(this)) { fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(handler, handler); } else { // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch")); - post_immediate_completion(p.p); + post_immediate_completion(p.p, false); p.v = p.p = 0; } } template <typename Handler> -void win_iocp_io_service::post(Handler handler) +void win_iocp_io_service::post(Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post")); - post_immediate_completion(p.p); + post_immediate_completion(p.p, false); p.v = p.p = 0; } template <typename Time_Traits> void win_iocp_io_service::add_timer_queue( timer_queue<Time_Traits>& queue) @@ -89,13 +90,13 @@ void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { // If the service has been shut down we silently discard the timer. if (::InterlockedExchangeAdd(&shutdown_, 0) != 0) { - post_immediate_completion(op); + post_immediate_completion(op, false); return; } mutex::scoped_lock lock(dispatch_mutex_); bool earliest = queue.enqueue_timer(time, timer, op); diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp index 72f4af7..fbc1cd0 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_iocp_io_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP @@ -16,17 +16,18 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/limits.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_iocp_io_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -65,19 +66,22 @@ struct win_iocp_io_service::timer_thread_function win_iocp_io_service::win_iocp_io_service( boost::asio::io_service& io_service, size_t concurrency_hint) : boost::asio::detail::service_base<win_iocp_io_service>(io_service), iocp_(), outstanding_work_(0), stopped_(0), + stop_event_posted_(0), shutdown_(0), + gqcs_timeout_(get_gqcs_timeout()), dispatch_required_(0) { BOOST_ASIO_HANDLER_TRACKING_INIT; iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, - static_cast<DWORD>((std::min<size_t>)(concurrency_hint, DWORD(~0)))); + static_cast<DWORD>(concurrency_hint < DWORD(~0) + ? concurrency_hint : DWORD(~0))); if (!iocp_.handle) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "iocp"); @@ -112,13 +116,13 @@ void win_iocp_io_service::shutdown_service() else { DWORD bytes_transferred = 0; dword_ptr_t completion_key = 0; LPOVERLAPPED overlapped = 0; ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred, - &completion_key, &overlapped, gqcs_timeout); + &completion_key, &overlapped, gqcs_timeout_); if (overlapped) { ::InterlockedDecrement(&outstanding_work_); static_cast<win_iocp_operation*>(overlapped)->destroy(); } } @@ -145,94 +149,100 @@ boost::system::error_code win_iocp_io_service::register_handle( } size_t win_iocp_io_service::run(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { - InterlockedExchange(&stopped_, 1); + stop(); ec = boost::system::error_code(); return 0; } - call_stack<win_iocp_io_service>::context ctx(this); + win_iocp_thread_info this_thread; + thread_call_stack::context ctx(this, this_thread); size_t n = 0; while (do_one(true, ec)) if (n != (std::numeric_limits<size_t>::max)()) ++n; return n; } size_t win_iocp_io_service::run_one(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { - InterlockedExchange(&stopped_, 1); + stop(); ec = boost::system::error_code(); return 0; } - call_stack<win_iocp_io_service>::context ctx(this); + win_iocp_thread_info this_thread; + thread_call_stack::context ctx(this, this_thread); return do_one(true, ec); } size_t win_iocp_io_service::poll(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { - InterlockedExchange(&stopped_, 1); + stop(); ec = boost::system::error_code(); return 0; } - call_stack<win_iocp_io_service>::context ctx(this); + win_iocp_thread_info this_thread; + thread_call_stack::context ctx(this, this_thread); size_t n = 0; while (do_one(false, ec)) if (n != (std::numeric_limits<size_t>::max)()) ++n; return n; } size_t win_iocp_io_service::poll_one(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { - InterlockedExchange(&stopped_, 1); + stop(); ec = boost::system::error_code(); return 0; } - call_stack<win_iocp_io_service>::context ctx(this); + win_iocp_thread_info this_thread; + thread_call_stack::context ctx(this, this_thread); return do_one(false, ec); } void win_iocp_io_service::stop() { if (::InterlockedExchange(&stopped_, 1) == 0) { - if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) + if (::InterlockedExchange(&stop_event_posted_, 1) == 0) { - DWORD last_error = ::GetLastError(); - boost::system::error_code ec(last_error, - boost::asio::error::get_system_category()); - boost::asio::detail::throw_error(ec, "pqcs"); + if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) + { + DWORD last_error = ::GetLastError(); + boost::system::error_code ec(last_error, + boost::asio::error::get_system_category()); + boost::asio::detail::throw_error(ec, "pqcs"); + } } } } void win_iocp_io_service::post_deferred_completion(win_iocp_operation* op) { // Flag the operation as ready. op->ready_ = 1; // Enqueue the operation on the I/O completion port. - if (!::PostQueuedCompletionStatus(iocp_.handle, - 0, overlapped_contains_result, op)) + if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); ::InterlockedExchange(&dispatch_required_, 1); } @@ -246,14 +256,13 @@ void win_iocp_io_service::post_deferred_completions( ops.pop(); // Flag the operation as ready. op->ready_ = 1; // Enqueue the operation on the I/O completion port. - if (!::PostQueuedCompletionStatus(iocp_.handle, - 0, overlapped_contains_result, op)) + if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); completed_ops_.push(ops); ::InterlockedExchange(&dispatch_required_, 1); @@ -353,13 +362,13 @@ size_t win_iocp_io_service::do_one(bool block, boost::system::error_code& ec) // Get the next operation from the queue. DWORD bytes_transferred = 0; dword_ptr_t completion_key = 0; LPOVERLAPPED overlapped = 0; ::SetLastError(0); BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred, - &completion_key, &overlapped, block ? gqcs_timeout : 0); + &completion_key, &overlapped, block ? gqcs_timeout_ : 0); DWORD last_error = ::GetLastError(); if (overlapped) { win_iocp_operation* op = static_cast<win_iocp_operation*>(overlapped); boost::system::error_code result_ec(last_error, @@ -418,32 +427,54 @@ size_t win_iocp_io_service::do_one(bool block, boost::system::error_code& ec) { // We have been woken up to try to acquire responsibility for dispatching // timers and completed operations. } else { + // Indicate that there is no longer an in-flight stop event. + ::InterlockedExchange(&stop_event_posted_, 0); + // The stopped_ flag is always checked to ensure that any leftover - // interrupts from a previous run invocation are ignored. + // stop events from a previous run invocation are ignored. if (::InterlockedExchangeAdd(&stopped_, 0) != 0) { // Wake up next thread that is blocked on GetQueuedCompletionStatus. - if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) + if (::InterlockedExchange(&stop_event_posted_, 1) == 0) { - last_error = ::GetLastError(); - ec = boost::system::error_code(last_error, - boost::asio::error::get_system_category()); - return 0; + if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) + { + last_error = ::GetLastError(); + ec = boost::system::error_code(last_error, + boost::asio::error::get_system_category()); + return 0; + } } ec = boost::system::error_code(); return 0; } } } } +DWORD win_iocp_io_service::get_gqcs_timeout() +{ + OSVERSIONINFOEX osvi; + ZeroMemory(&osvi, sizeof(osvi)); + osvi.dwOSVersionInfoSize = sizeof(osvi); + osvi.dwMajorVersion = 6ul; + + const uint64_t condition_mask = ::VerSetConditionMask( + 0, VER_MAJORVERSION, VER_GREATER_EQUAL); + + if (!!::VerifyVersionInfo(&osvi, VER_MAJORVERSION, condition_mask)) + return INFINITE; + + return default_gqcs_timeout; +} + void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(dispatch_mutex_); timer_queues_.insert(&queue); diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp index e98ad87..e3081af 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_iocp_serial_port_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp index 0466e33..40231b9 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_iocp_socket_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP @@ -29,12 +29,13 @@ namespace detail { win_iocp_socket_service_base::win_iocp_socket_service_base( boost::asio::io_service& io_service) : io_service_(io_service), iocp_service_(use_service<win_iocp_io_service>(io_service)), reactor_(0), + connect_ex_(0), mutex_(), impl_list_(0) { } void win_iocp_socket_service_base::shutdown_service() @@ -531,25 +532,68 @@ void win_iocp_socket_service_base::start_reactor_op( { reactor& r = get_reactor(); update_cancellation_thread_id(impl); if (is_open(impl)) { - r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false); + r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false, false); return; } else op->ec_ = boost::asio::error::bad_descriptor; - iocp_service_.post_immediate_completion(op); + iocp_service_.post_immediate_completion(op, false); } void win_iocp_socket_service_base::start_connect_op( win_iocp_socket_service_base::base_implementation_type& impl, - reactor_op* op, const socket_addr_type* addr, std::size_t addrlen) + int family, int type, const socket_addr_type* addr, + std::size_t addrlen, win_iocp_socket_connect_op_base* op) { + // If ConnectEx is available, use that. + if (family == BOOST_ASIO_OS_DEF(AF_INET) + || family == BOOST_ASIO_OS_DEF(AF_INET6)) + { + if (connect_ex_fn connect_ex = get_connect_ex(impl, type)) + { + union address_union + { + socket_addr_type base; + sockaddr_in4_type v4; + sockaddr_in6_type v6; + } a; + + using namespace std; // For memset. + memset(&a, 0, sizeof(a)); + a.base.sa_family = family; + + socket_ops::bind(impl.socket_, &a.base, + family == BOOST_ASIO_OS_DEF(AF_INET) + ? sizeof(a.v4) : sizeof(a.v6), op->ec_); + if (op->ec_ && op->ec_ != boost::asio::error::invalid_argument) + { + iocp_service_.post_immediate_completion(op, false); + return; + } + + op->connect_ex_ = true; + update_cancellation_thread_id(impl); + iocp_service_.work_started(); + + BOOL result = connect_ex(impl.socket_, + addr, static_cast<int>(addrlen), 0, 0, 0, op); + DWORD last_error = ::WSAGetLastError(); + if (!result && last_error != WSA_IO_PENDING) + iocp_service_.on_completion(op, last_error); + else + iocp_service_.on_pending(op); + return; + } + } + + // Otherwise, fall back to a reactor-based implementation. reactor& r = get_reactor(); update_cancellation_thread_id(impl); if ((impl.state_ & socket_ops::non_blocking) != 0 || socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) @@ -558,19 +602,19 @@ void win_iocp_socket_service_base::start_connect_op( { if (op->ec_ == boost::asio::error::in_progress || op->ec_ == boost::asio::error::would_block) { op->ec_ = boost::system::error_code(); r.start_op(reactor::connect_op, impl.socket_, - impl.reactor_data_, op, false); + impl.reactor_data_, op, false, false); return; } } } - r.post_immediate_completion(op); + r.post_immediate_completion(op, false); } void win_iocp_socket_service_base::close_for_destruction( win_iocp_socket_service_base::base_implementation_type& impl) { if (is_open(impl)) @@ -620,12 +664,41 @@ reactor& win_iocp_socket_service_base::get_reactor() r = &(use_service<reactor>(io_service_)); interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r); } return *r; } +win_iocp_socket_service_base::connect_ex_fn +win_iocp_socket_service_base::get_connect_ex( + win_iocp_socket_service_base::base_implementation_type& impl, int type) +{ + if (type != BOOST_ASIO_OS_DEF(SOCK_STREAM) + && type != BOOST_ASIO_OS_DEF(SOCK_SEQPACKET)) + return 0; + + void* ptr = interlocked_compare_exchange_pointer(&connect_ex_, 0, 0); + if (!ptr) + { + GUID guid = { 0x25a207b9, 0xddf3, 0x4660, + { 0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e } }; + + DWORD bytes = 0; + if (::WSAIoctl(impl.socket_, SIO_GET_EXTENSION_FUNCTION_POINTER, + &guid, sizeof(guid), &ptr, sizeof(ptr), &bytes, 0, 0) != 0) + { + // Set connect_ex_ to a special value to indicate that ConnectEx is + // unavailable. That way we won't bother trying to look it up again. + ptr = this; + } + + interlocked_exchange_pointer(&connect_ex_, ptr); + } + + return reinterpret_cast<connect_ex_fn>(ptr == this ? 0 : ptr); +} + void* win_iocp_socket_service_base::interlocked_compare_exchange_pointer( void** dest, void* exch, void* cmp) { #if defined(_M_IX86) return reinterpret_cast<void*>(InterlockedCompareExchange( reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch), diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp index 05a7492..f86012b 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_MUTEX_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_mutex.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -72,9 +72,9 @@ int win_mutex::do_init() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp index d91ccac..081d5eb 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_object_handle_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2011 Boris Schaeling (boris@highscore.de) // // 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) // @@ -418,13 +418,13 @@ void win_object_handle_service::wait_callback(PVOID param, BOOLEAN) param, INFINITE, WT_EXECUTEONLYONCE)) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); - while (wait_op* op = impl->op_queue_.front()) + while ((op = impl->op_queue_.front()) != 0) { op->ec_ = ec; impl->op_queue_.pop(); completed_ops.push(op); } } diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp index 3ec104d..84bd454 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_static_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <cstdio> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_static_mutex.hpp> #include <boost/asio/error.hpp> @@ -39,18 +39,18 @@ void win_static_mutex::init() } int win_static_mutex::do_init() { using namespace std; // For sprintf. wchar_t mutex_name[128]; -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) - swprintf_s(mutex_name, 128, -#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) - swprintf(mutex_name, -#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE) - L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p", +#if defined(BOOST_ASIO_HAS_SECURE_RTL) + swprintf_s( +#else // defined(BOOST_ASIO_HAS_SECURE_RTL) + _snwprintf( +#endif // defined(BOOST_ASIO_HAS_SECURE_RTL) + mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p", static_cast<unsigned int>(::GetCurrentProcessId()), this); HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name); DWORD last_error = ::GetLastError(); if (mutex == 0) return ::GetLastError(); @@ -112,9 +112,9 @@ int win_static_mutex::do_init() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp index 744990d..4bf09c5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_thread.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_THREAD_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #include <process.h> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_thread.hpp> #include <boost/asio/error.hpp> @@ -133,9 +133,9 @@ void __stdcall apc_function(ULONG_PTR) {} } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp index 9da761c..abaad27 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp @@ -1,11 +1,11 @@ // // detail/impl/win_tss_ptr.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_tss_ptr.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -51,9 +51,9 @@ DWORD win_tss_ptr_create() } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp new file mode 100644 index 0000000..fdd0465 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp @@ -0,0 +1,614 @@ +// +// detail/impl/winrt_ssocket_service_base.ipp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP +#define BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <cstring> +#include <boost/asio/detail/winrt_ssocket_service_base.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/detail/winrt_utils.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +winrt_ssocket_service_base::winrt_ssocket_service_base( + boost::asio::io_service& io_service) + : io_service_(use_service<io_service_impl>(io_service)), + async_manager_(use_service<winrt_async_manager>(io_service)), + mutex_(), + impl_list_(0) +{ +} + +void winrt_ssocket_service_base::shutdown_service() +{ + // Close all implementations, causing all operations to complete. + boost::asio::detail::mutex::scoped_lock lock(mutex_); + base_implementation_type* impl = impl_list_; + while (impl) + { + boost::system::error_code ignored_ec; + close(*impl, ignored_ec); + impl = impl->next_; + } +} + +void winrt_ssocket_service_base::construct( + winrt_ssocket_service_base::base_implementation_type& impl) +{ + // Insert implementation into linked list of all implementations. + boost::asio::detail::mutex::scoped_lock lock(mutex_); + impl.next_ = impl_list_; + impl.prev_ = 0; + if (impl_list_) + impl_list_->prev_ = &impl; + impl_list_ = &impl; +} + +void winrt_ssocket_service_base::base_move_construct( + winrt_ssocket_service_base::base_implementation_type& impl, + winrt_ssocket_service_base::base_implementation_type& other_impl) +{ + impl.socket_ = other_impl.socket_; + other_impl.socket_ = nullptr; + + // Insert implementation into linked list of all implementations. + boost::asio::detail::mutex::scoped_lock lock(mutex_); + impl.next_ = impl_list_; + impl.prev_ = 0; + if (impl_list_) + impl_list_->prev_ = &impl; + impl_list_ = &impl; +} + +void winrt_ssocket_service_base::base_move_assign( + winrt_ssocket_service_base::base_implementation_type& impl, + winrt_ssocket_service_base& other_service, + winrt_ssocket_service_base::base_implementation_type& other_impl) +{ + boost::system::error_code ignored_ec; + close(impl, ignored_ec); + + if (this != &other_service) + { + // Remove implementation from linked list of all implementations. + boost::asio::detail::mutex::scoped_lock lock(mutex_); + if (impl_list_ == &impl) + impl_list_ = impl.next_; + if (impl.prev_) + impl.prev_->next_ = impl.next_; + if (impl.next_) + impl.next_->prev_= impl.prev_; + impl.next_ = 0; + impl.prev_ = 0; + } + + impl.socket_ = other_impl.socket_; + other_impl.socket_ = nullptr; + + if (this != &other_service) + { + // Insert implementation into linked list of all implementations. + boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_); + impl.next_ = other_service.impl_list_; + impl.prev_ = 0; + if (other_service.impl_list_) + other_service.impl_list_->prev_ = &impl; + other_service.impl_list_ = &impl; + } +} + +void winrt_ssocket_service_base::destroy( + winrt_ssocket_service_base::base_implementation_type& impl) +{ + boost::system::error_code ignored_ec; + close(impl, ignored_ec); + + // Remove implementation from linked list of all implementations. + boost::asio::detail::mutex::scoped_lock lock(mutex_); + if (impl_list_ == &impl) + impl_list_ = impl.next_; + if (impl.prev_) + impl.prev_->next_ = impl.next_; + if (impl.next_) + impl.next_->prev_= impl.prev_; + impl.next_ = 0; + impl.prev_ = 0; +} + +boost::system::error_code winrt_ssocket_service_base::close( + winrt_ssocket_service_base::base_implementation_type& impl, + boost::system::error_code& ec) +{ + if (impl.socket_) + { + delete impl.socket_; + impl.socket_ = nullptr; + } + + ec = boost::system::error_code(); + return ec; +} + +std::size_t winrt_ssocket_service_base::do_get_endpoint( + const base_implementation_type& impl, bool local, + void* addr, std::size_t addr_len, boost::system::error_code& ec) const +{ + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return addr_len; + } + + try + { + std::string addr_string = winrt_utils::string(local + ? impl.socket_->Information->LocalAddress->CanonicalName + : impl.socket_->Information->RemoteAddress->CanonicalName); + unsigned short port = winrt_utils::integer(local + ? impl.socket_->Information->LocalPort + : impl.socket_->Information->RemotePort); + unsigned long scope = 0; + + switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family) + { + case BOOST_ASIO_OS_DEF(AF_INET): + if (addr_len < sizeof(sockaddr_in4_type)) + { + ec = boost::asio::error::invalid_argument; + return addr_len; + } + else + { + socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET), addr_string.c_str(), + &reinterpret_cast<sockaddr_in4_type*>(addr)->sin_addr, &scope, ec); + reinterpret_cast<sockaddr_in4_type*>(addr)->sin_port + = socket_ops::host_to_network_short(port); + ec = boost::system::error_code(); + return sizeof(sockaddr_in4_type); + } + case BOOST_ASIO_OS_DEF(AF_INET6): + if (addr_len < sizeof(sockaddr_in6_type)) + { + ec = boost::asio::error::invalid_argument; + return addr_len; + } + else + { + socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6), addr_string.c_str(), + &reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_addr, &scope, ec); + reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_port + = socket_ops::host_to_network_short(port); + ec = boost::system::error_code(); + return sizeof(sockaddr_in6_type); + } + default: + ec = boost::asio::error::address_family_not_supported; + return addr_len; + } + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + return addr_len; + } +} + +boost::system::error_code winrt_ssocket_service_base::do_set_option( + winrt_ssocket_service_base::base_implementation_type& impl, + int level, int optname, const void* optval, + std::size_t optlen, boost::system::error_code& ec) +{ + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return ec; + } + + try + { + if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET) + && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE)) + { + if (optlen == sizeof(int)) + { + int value = 0; + std::memcpy(&value, optval, optlen); + impl.socket_->Control->KeepAlive = !!value; + ec = boost::system::error_code(); + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP) + && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY)) + { + if (optlen == sizeof(int)) + { + int value = 0; + std::memcpy(&value, optval, optlen); + impl.socket_->Control->NoDelay = !!value; + ec = boost::system::error_code(); + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + } + + return ec; +} + +void winrt_ssocket_service_base::do_get_option( + const winrt_ssocket_service_base::base_implementation_type& impl, + int level, int optname, void* optval, + std::size_t* optlen, boost::system::error_code& ec) const +{ + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return; + } + + try + { + if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET) + && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE)) + { + if (*optlen >= sizeof(int)) + { + int value = impl.socket_->Control->KeepAlive ? 1 : 0; + std::memcpy(optval, &value, sizeof(int)); + *optlen = sizeof(int); + ec = boost::system::error_code(); + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP) + && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY)) + { + if (*optlen >= sizeof(int)) + { + int value = impl.socket_->Control->NoDelay ? 1 : 0; + std::memcpy(optval, &value, sizeof(int)); + *optlen = sizeof(int); + ec = boost::system::error_code(); + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + else + { + ec = boost::asio::error::invalid_argument; + } + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + } +} + +boost::system::error_code winrt_ssocket_service_base::do_connect( + winrt_ssocket_service_base::base_implementation_type& impl, + const void* addr, boost::system::error_code& ec) +{ + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return ec; + } + + char addr_string[max_addr_v6_str_len]; + unsigned short port; + switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family) + { + case BOOST_ASIO_OS_DEF(AF_INET): + socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET), + &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr, + addr_string, sizeof(addr_string), 0, ec); + port = socket_ops::network_to_host_short( + reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port); + break; + case BOOST_ASIO_OS_DEF(AF_INET6): + socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6), + &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr, + addr_string, sizeof(addr_string), 0, ec); + port = socket_ops::network_to_host_short( + reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port); + break; + default: + ec = boost::asio::error::address_family_not_supported; + return ec; + } + + if (!ec) try + { + async_manager_.sync(impl.socket_->ConnectAsync( + ref new Windows::Networking::HostName( + winrt_utils::string(addr_string)), + winrt_utils::string(port)), ec); + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + } + + return ec; +} + +void winrt_ssocket_service_base::start_connect_op( + winrt_ssocket_service_base::base_implementation_type& impl, + const void* addr, winrt_async_op<void>* op, bool is_continuation) +{ + if (!is_open(impl)) + { + op->ec_ = boost::asio::error::bad_descriptor; + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + char addr_string[max_addr_v6_str_len]; + unsigned short port = 0; + switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family) + { + case BOOST_ASIO_OS_DEF(AF_INET): + socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET), + &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr, + addr_string, sizeof(addr_string), 0, op->ec_); + port = socket_ops::network_to_host_short( + reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port); + break; + case BOOST_ASIO_OS_DEF(AF_INET6): + socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6), + &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr, + addr_string, sizeof(addr_string), 0, op->ec_); + port = socket_ops::network_to_host_short( + reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port); + break; + default: + op->ec_ = boost::asio::error::address_family_not_supported; + break; + } + + if (op->ec_) + { + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + try + { + async_manager_.async(impl.socket_->ConnectAsync( + ref new Windows::Networking::HostName( + winrt_utils::string(addr_string)), + winrt_utils::string(port)), op); + } + catch (Platform::Exception^ e) + { + op->ec_ = boost::system::error_code( + e->HResult, boost::system::system_category()); + io_service_.post_immediate_completion(op, is_continuation); + } +} + +std::size_t winrt_ssocket_service_base::do_send( + winrt_ssocket_service_base::base_implementation_type& impl, + const boost::asio::const_buffer& data, + socket_base::message_flags flags, boost::system::error_code& ec) +{ + if (flags) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return 0; + } + + try + { + buffer_sequence_adapter<boost::asio::const_buffer, + boost::asio::const_buffers_1> bufs(boost::asio::buffer(data)); + + if (bufs.all_empty()) + { + ec = boost::system::error_code(); + return 0; + } + + return async_manager_.sync( + impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), ec); + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + return 0; + } +} + +void winrt_ssocket_service_base::start_send_op( + winrt_ssocket_service_base::base_implementation_type& impl, + const boost::asio::const_buffer& data, socket_base::message_flags flags, + winrt_async_op<unsigned int>* op, bool is_continuation) +{ + if (flags) + { + op->ec_ = boost::asio::error::operation_not_supported; + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + if (!is_open(impl)) + { + op->ec_ = boost::asio::error::bad_descriptor; + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + try + { + buffer_sequence_adapter<boost::asio::const_buffer, + boost::asio::const_buffers_1> bufs(boost::asio::buffer(data)); + + if (bufs.all_empty()) + { + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + async_manager_.async( + impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), op); + } + catch (Platform::Exception^ e) + { + op->ec_ = boost::system::error_code(e->HResult, + boost::system::system_category()); + io_service_.post_immediate_completion(op, is_continuation); + } +} + +std::size_t winrt_ssocket_service_base::do_receive( + winrt_ssocket_service_base::base_implementation_type& impl, + const boost::asio::mutable_buffer& data, + socket_base::message_flags flags, boost::system::error_code& ec) +{ + if (flags) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + if (!is_open(impl)) + { + ec = boost::asio::error::bad_descriptor; + return 0; + } + + try + { + buffer_sequence_adapter<boost::asio::mutable_buffer, + boost::asio::mutable_buffers_1> bufs(boost::asio::buffer(data)); + + if (bufs.all_empty()) + { + ec = boost::system::error_code(); + return 0; + } + + async_manager_.sync( + impl.socket_->InputStream->ReadAsync( + bufs.buffers()[0], bufs.buffers()[0]->Capacity, + Windows::Storage::Streams::InputStreamOptions::Partial), ec); + + std::size_t bytes_transferred = bufs.buffers()[0]->Length; + if (bytes_transferred == 0 && !ec) + { + ec = boost::asio::error::eof; + } + + return bytes_transferred; + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + return 0; + } +} + +void winrt_ssocket_service_base::start_receive_op( + winrt_ssocket_service_base::base_implementation_type& impl, + const boost::asio::mutable_buffer& data, socket_base::message_flags flags, + winrt_async_op<Windows::Storage::Streams::IBuffer^>* op, + bool is_continuation) +{ + if (flags) + { + op->ec_ = boost::asio::error::operation_not_supported; + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + if (!is_open(impl)) + { + op->ec_ = boost::asio::error::bad_descriptor; + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + try + { + buffer_sequence_adapter<boost::asio::mutable_buffer, + boost::asio::mutable_buffers_1> bufs(boost::asio::buffer(data)); + + if (bufs.all_empty()) + { + io_service_.post_immediate_completion(op, is_continuation); + return; + } + + async_manager_.async( + impl.socket_->InputStream->ReadAsync( + bufs.buffers()[0], bufs.buffers()[0]->Capacity, + Windows::Storage::Streams::InputStreamOptions::Partial), op); + } + catch (Platform::Exception^ e) + { + op->ec_ = boost::system::error_code(e->HResult, + boost::system::system_category()); + io_service_.post_immediate_completion(op, is_continuation); + } +} + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp new file mode 100644 index 0000000..ff1ee03 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp @@ -0,0 +1,81 @@ +// +// detail/impl/winrt_timer_scheduler.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP +#define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Time_Traits> +void winrt_timer_scheduler::add_timer_queue(timer_queue<Time_Traits>& queue) +{ + do_add_timer_queue(queue); +} + +// Remove a timer queue from the reactor. +template <typename Time_Traits> +void winrt_timer_scheduler::remove_timer_queue(timer_queue<Time_Traits>& queue) +{ + do_remove_timer_queue(queue); +} + +template <typename Time_Traits> +void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue, + const typename Time_Traits::time_type& time, + typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) +{ + boost::asio::detail::mutex::scoped_lock lock(mutex_); + + if (shutdown_) + { + io_service_.post_immediate_completion(op, false); + return; + } + + bool earliest = queue.enqueue_timer(time, timer, op); + io_service_.work_started(); + if (earliest) + event_.signal(lock); +} + +template <typename Time_Traits> +std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue, + typename timer_queue<Time_Traits>::per_timer_data& timer, + std::size_t max_cancelled) +{ + boost::asio::detail::mutex::scoped_lock lock(mutex_); + op_queue<operation> ops; + std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); + lock.unlock(); + io_service_.post_deferred_completions(ops); + return n; +} + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp new file mode 100644 index 0000000..ef480ea --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp @@ -0,0 +1,124 @@ +// +// detail/impl/winrt_timer_scheduler.ipp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP +#define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/winrt_timer_scheduler.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +winrt_timer_scheduler::winrt_timer_scheduler( + boost::asio::io_service& io_service) + : boost::asio::detail::service_base<winrt_timer_scheduler>(io_service), + io_service_(use_service<io_service_impl>(io_service)), + mutex_(), + event_(), + timer_queues_(), + thread_(0), + stop_thread_(false), + shutdown_(false) +{ + thread_ = new boost::asio::detail::thread( + bind_handler(&winrt_timer_scheduler::call_run_thread, this)); +} + +winrt_timer_scheduler::~winrt_timer_scheduler() +{ + shutdown_service(); +} + +void winrt_timer_scheduler::shutdown_service() +{ + boost::asio::detail::mutex::scoped_lock lock(mutex_); + shutdown_ = true; + stop_thread_ = true; + event_.signal(lock); + lock.unlock(); + + if (thread_) + { + thread_->join(); + delete thread_; + thread_ = 0; + } + + op_queue<operation> ops; + timer_queues_.get_all_timers(ops); + io_service_.abandon_operations(ops); +} + +void winrt_timer_scheduler::fork_service(boost::asio::io_service::fork_event) +{ +} + +void winrt_timer_scheduler::init_task() +{ +} + +void winrt_timer_scheduler::run_thread() +{ + boost::asio::detail::mutex::scoped_lock lock(mutex_); + while (!stop_thread_) + { + const long max_wait_duration = 5 * 60 * 1000000; + long wait_duration = timer_queues_.wait_duration_usec(max_wait_duration); + event_.wait_for_usec(lock, wait_duration); + event_.clear(lock); + op_queue<operation> ops; + timer_queues_.get_ready_timers(ops); + if (!ops.empty()) + { + lock.unlock(); + io_service_.post_deferred_completions(ops); + lock.lock(); + } + } +} + +void winrt_timer_scheduler::call_run_thread(winrt_timer_scheduler* scheduler) +{ + scheduler->run_thread(); +} + +void winrt_timer_scheduler::do_add_timer_queue(timer_queue_base& queue) +{ + mutex::scoped_lock lock(mutex_); + timer_queues_.insert(&queue); +} + +void winrt_timer_scheduler::do_remove_timer_queue(timer_queue_base& queue) +{ + mutex::scoped_lock lock(mutex_); + timer_queues_.erase(&queue); +} + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp index 8916934..08f3280 100644 --- a/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp +++ b/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp @@ -1,11 +1,11 @@ // // detail/impl/winsock_init.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/winsock_init.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> @@ -38,20 +38,33 @@ void winsock_init_base::startup(data& d, WSADATA wsa_data; long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data); ::InterlockedExchange(&d.result_, result); } } +void winsock_init_base::manual_startup(data& d) +{ + if (::InterlockedIncrement(&d.init_count_) == 1) + { + ::InterlockedExchange(&d.result_, 0); + } +} + void winsock_init_base::cleanup(data& d) { if (::InterlockedDecrement(&d.init_count_) == 0) { ::WSACleanup(); } } +void winsock_init_base::manual_cleanup(data& d) +{ + ::InterlockedDecrement(&d.init_count_); +} + void winsock_init_base::throw_on_error(data& d) { long result = ::InterlockedExchangeAdd(&d.result_, 0); if (result != 0) { boost::system::error_code ec(result, @@ -63,9 +76,9 @@ void winsock_init_base::throw_on_error(data& d) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP diff --git a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp index e08a4fc..31d2f0e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp @@ -1,11 +1,11 @@ // // detail/io_control.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_IO_CONTROL_HPP @@ -14,13 +14,12 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> -#include <boost/config.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { @@ -43,13 +42,13 @@ public: { } // Get the name of the IO control command. int name() const { - return static_cast<int>(FIONBIO); + return static_cast<int>(BOOST_ASIO_OS_DEF(FIONBIO)); } // Set the value of the I/O control command. void set(bool value) { value_ = value ? 1 : 0; @@ -93,13 +92,13 @@ public: { } // Get the name of the IO control command. int name() const { - return static_cast<int>(FIONREAD); + return static_cast<int>(BOOST_ASIO_OS_DEF(FIONREAD)); } // Set the value of the I/O control command. void set(std::size_t value) { value_ = static_cast<detail::ioctl_arg_type>(value); diff --git a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp index 10dd01a..cd32b50 100644 --- a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp @@ -1,11 +1,11 @@ // // detail/keyword_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP @@ -52,17 +52,17 @@ public: void operator=(T* value) { value_ = value; } private: - static __thread T* value_; + static BOOST_ASIO_THREAD_KEYWORD T* value_; }; template <typename T> -__thread T* keyword_tss_ptr<T>::value_; +BOOST_ASIO_THREAD_KEYWORD T* keyword_tss_ptr<T>::value_; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp index b3e111d..37c70b2 100644 --- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp @@ -1,11 +1,11 @@ // // detail/kqueue_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com) // // 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) // @@ -17,26 +17,24 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_KQUEUE) -#include <boost/limits.hpp> #include <cstddef> #include <sys/types.h> #include <sys/event.h> #include <sys/time.h> -#include <boost/asio/detail/kqueue_reactor_fwd.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/object_pool.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> -#include <boost/asio/detail/timer_queue_fwd.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> // Older versions of Mac OS X may not define EV_OOBAND. @@ -105,22 +103,22 @@ public: // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. - void post_immediate_completion(reactor_op* op) + void post_immediate_completion(reactor_op* op, bool is_continuation) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, - per_descriptor_data& descriptor_data, - reactor_op* op, bool allow_speculative); + per_descriptor_data& descriptor_data, reactor_op* op, + bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data& descriptor_data); diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp deleted file mode 100644 index 517a307..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// detail/kqueue_reactor_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com) -// -// 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_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP -#define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -#include <boost/asio/detail/config.hpp> - -#if defined(BOOST_ASIO_HAS_KQUEUE) - -namespace boost { -namespace asio { -namespace detail { - -class kqueue_reactor; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // defined(BOOST_ASIO_HAS_KQUEUE) - -#endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/limits.hpp b/3rdParty/Boost/src/boost/asio/detail/limits.hpp new file mode 100644 index 0000000..036c599 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/limits.hpp @@ -0,0 +1,26 @@ +// +// detail/limits.hpp +// ~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_LIMITS_HPP +#define BOOST_ASIO_DETAIL_LIMITS_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_BOOST_LIMITS) +# include <boost/limits.hpp> +#else // defined(BOOST_ASIO_HAS_BOOST_LIMITS) +# include <limits> +#endif // defined(BOOST_ASIO_HAS_BOOST_LIMITS) + +#endif // BOOST_ASIO_DETAIL_LIMITS_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp index dc3b47d..aee4bfb 100644 --- a/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/macos_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_MACOS_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/mutex.hpp index bd3e0c6..8212ec3 100644 --- a/3rdParty/Boost/src/boost/asio/detail/mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/mutex.hpp @@ -1,11 +1,11 @@ // // detail/mutex.hpp // ~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_MUTEX_HPP @@ -14,32 +14,36 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) # include <boost/asio/detail/null_mutex.hpp> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_mutex.hpp> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_mutex.hpp> +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +# include <boost/asio/detail/std_mutex.hpp> #else -# error Only Windows and POSIX are supported! +# error Only Windows, POSIX and std::mutex are supported! #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) typedef null_mutex mutex; -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) typedef win_mutex mutex; -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_mutex mutex; +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +typedef std_mutex mutex; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp index 5f7e8cc..6aae476 100644 --- a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp @@ -1,11 +1,11 @@ // // detail/noncopyable.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NONCOPYABLE_HPP @@ -13,38 +13,28 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/noncopyable.hpp> -#include <boost/detail/workaround.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -// Redefine the noncopyable class for Borland C++ since that compiler does not -// apply the empty base optimisation unless the base class contains a dummy -// char data member. class noncopyable { protected: noncopyable() {} ~noncopyable() {} private: noncopyable(const noncopyable&); const noncopyable& operator=(const noncopyable&); - char dummy_; }; -#else -using boost::noncopyable; -#endif } // namespace detail using boost::asio::detail::noncopyable; } // namespace asio diff --git a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp index 1130d18..2e87844 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp @@ -1,11 +1,11 @@ // // detail/null_event.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_EVENT_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -38,24 +38,37 @@ public: // Destructor. ~null_event() { } - // Signal the event. + // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock&) { } - // Signal the event and unlock the mutex. + // Signal all waiters. template <typename Lock> - void signal_and_unlock(Lock&) + void signal_all(Lock&) { } + // Unlock the mutex and signal one waiter. + template <typename Lock> + void unlock_and_signal_one(Lock&) + { + } + + // If there's a waiter, unlock the mutex and signal it. + template <typename Lock> + bool maybe_unlock_and_signal_one(Lock&) + { + return false; + } + // Reset the event. template <typename Lock> void clear(Lock&) { } @@ -69,9 +82,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_EVENT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp index 64bedec..cf5da6e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/null_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp index 5d810bb..c282303 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp @@ -1,11 +1,11 @@ // // detail/null_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> @@ -58,9 +58,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp new file mode 100644 index 0000000..a8e93e1 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp @@ -0,0 +1,69 @@ +// +// detail/null_reactor.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_NULL_REACTOR_HPP +#define BOOST_ASIO_DETAIL_NULL_REACTOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/io_service.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class null_reactor + : public boost::asio::detail::service_base<null_reactor> +{ +public: + // Constructor. + null_reactor(boost::asio::io_service& io_service) + : boost::asio::detail::service_base<null_reactor>(io_service) + { + } + + // Destructor. + ~null_reactor() + { + } + + // Destroy all user-defined handler objects owned by the service. + void shutdown_service() + { + } + + // No-op because should never be called. + void run(bool /*block*/, op_queue<operation>& /*ops*/) + { + } + + // No-op. + void interrupt() + { + } +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_NULL_REACTOR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp index 5eeb293..89008fc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp @@ -1,11 +1,11 @@ // // detail/null_signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP @@ -14,15 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) \ - || defined(BOOST_ASIO_DISABLE_THREADS) \ - || defined(BOOST_WINDOWS) \ +#if !defined(BOOST_ASIO_HAS_THREADS) \ + || defined(BOOST_ASIO_WINDOWS) \ + || defined(BOOST_ASIO_WINDOWS_RUNTIME) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> @@ -59,13 +59,13 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) - // || defined(BOOST_ASIO_DISABLE_THREADS) - // || defined(BOOST_WINDOWS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) + // || defined(BOOST_ASIO_WINDOWS) + // || defined(BOOST_ASIO_WINDOWS_RUNTIME) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) #endif // BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp new file mode 100644 index 0000000..aafa1b7 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp @@ -0,0 +1,499 @@ +// +// detail/null_socket_service.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP +#define BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/buffer.hpp> +#include <boost/asio/error.hpp> +#include <boost/asio/io_service.hpp> +#include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/bind_handler.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Protocol> +class null_socket_service +{ +public: + // The protocol type. + typedef Protocol protocol_type; + + // The endpoint type. + typedef typename Protocol::endpoint endpoint_type; + + // The native type of a socket. + typedef int native_handle_type; + + // The implementation type of the socket. + struct implementation_type + { + }; + + // Constructor. + null_socket_service(boost::asio::io_service& io_service) + : io_service_(io_service) + { + } + + // Destroy all user-defined handler objects owned by the service. + void shutdown_service() + { + } + + // Construct a new socket implementation. + void construct(implementation_type&) + { + } + + // Move-construct a new socket implementation. + void move_construct(implementation_type&, implementation_type&) + { + } + + // Move-assign from another socket implementation. + void move_assign(implementation_type&, + null_socket_service&, implementation_type&) + { + } + + // Move-construct a new socket implementation from another protocol type. + template <typename Protocol1> + void converting_move_construct(implementation_type&, + typename null_socket_service<Protocol1>::implementation_type&) + { + } + + // Destroy a socket implementation. + void destroy(implementation_type&) + { + } + + // Open a new socket implementation. + boost::system::error_code open(implementation_type&, + const protocol_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Assign a native socket to a socket implementation. + boost::system::error_code assign(implementation_type&, const protocol_type&, + const native_handle_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Determine whether the socket is open. + bool is_open(const implementation_type&) const + { + return false; + } + + // Destroy a socket implementation. + boost::system::error_code close(implementation_type&, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Get the native socket representation. + native_handle_type native_handle(implementation_type&) + { + return 0; + } + + // Cancel all operations associated with the socket. + boost::system::error_code cancel(implementation_type&, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Determine whether the socket is at the out-of-band data mark. + bool at_mark(const implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return false; + } + + // Determine the number of bytes available for reading. + std::size_t available(const implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Place the socket into the state where it will listen for new connections. + boost::system::error_code listen(implementation_type&, + int, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Perform an IO control command on the socket. + template <typename IO_Control_Command> + boost::system::error_code io_control(implementation_type&, + IO_Control_Command&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Gets the non-blocking mode of the socket. + bool non_blocking(const implementation_type&) const + { + return false; + } + + // Sets the non-blocking mode of the socket. + boost::system::error_code non_blocking(implementation_type&, + bool, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Gets the non-blocking mode of the native socket implementation. + bool native_non_blocking(const implementation_type&) const + { + return false; + } + + // Sets the non-blocking mode of the native socket implementation. + boost::system::error_code native_non_blocking(implementation_type&, + bool, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Disable sends or receives on the socket. + boost::system::error_code shutdown(implementation_type&, + socket_base::shutdown_type, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Bind the socket to the specified local endpoint. + boost::system::error_code bind(implementation_type&, + const endpoint_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Set a socket option. + template <typename Option> + boost::system::error_code set_option(implementation_type&, + const Option&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Set a socket option. + template <typename Option> + boost::system::error_code get_option(const implementation_type&, + Option&, boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Get the local endpoint. + endpoint_type local_endpoint(const implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return endpoint_type(); + } + + // Get the remote endpoint. + endpoint_type remote_endpoint(const implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return endpoint_type(); + } + + // Send the given data to the peer. + template <typename ConstBufferSequence> + std::size_t send(implementation_type&, const ConstBufferSequence&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Wait until data can be sent without blocking. + std::size_t send(implementation_type&, const null_buffers&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous send. The data being sent must be valid for the + // lifetime of the asynchronous operation. + template <typename ConstBufferSequence, typename Handler> + void async_send(implementation_type&, const ConstBufferSequence&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Start an asynchronous wait until data can be sent without blocking. + template <typename Handler> + void async_send(implementation_type&, const null_buffers&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Receive some data from the peer. Returns the number of bytes received. + template <typename MutableBufferSequence> + std::size_t receive(implementation_type&, const MutableBufferSequence&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Wait until data can be received without blocking. + std::size_t receive(implementation_type&, const null_buffers&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous receive. The buffer for the data being received + // must be valid for the lifetime of the asynchronous operation. + template <typename MutableBufferSequence, typename Handler> + void async_receive(implementation_type&, const MutableBufferSequence&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Wait until data can be received without blocking. + template <typename Handler> + void async_receive(implementation_type&, const null_buffers&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Receive some data with associated flags. Returns the number of bytes + // received. + template <typename MutableBufferSequence> + std::size_t receive_with_flags(implementation_type&, + const MutableBufferSequence&, socket_base::message_flags, + socket_base::message_flags&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Wait until data can be received without blocking. + std::size_t receive_with_flags(implementation_type&, + const null_buffers&, socket_base::message_flags, + socket_base::message_flags&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous receive. The buffer for the data being received + // must be valid for the lifetime of the asynchronous operation. + template <typename MutableBufferSequence, typename Handler> + void async_receive_with_flags(implementation_type&, + const MutableBufferSequence&, socket_base::message_flags, + socket_base::message_flags&, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Wait until data can be received without blocking. + template <typename Handler> + void async_receive_with_flags(implementation_type&, + const null_buffers&, socket_base::message_flags, + socket_base::message_flags&, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Send a datagram to the specified endpoint. Returns the number of bytes + // sent. + template <typename ConstBufferSequence> + std::size_t send_to(implementation_type&, const ConstBufferSequence&, + const endpoint_type&, socket_base::message_flags, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Wait until data can be sent without blocking. + std::size_t send_to(implementation_type&, const null_buffers&, + const endpoint_type&, socket_base::message_flags, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous send. The data being sent must be valid for the + // lifetime of the asynchronous operation. + template <typename ConstBufferSequence, typename Handler> + void async_send_to(implementation_type&, const ConstBufferSequence&, + const endpoint_type&, socket_base::message_flags, + Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Start an asynchronous wait until data can be sent without blocking. + template <typename Handler> + void async_send_to(implementation_type&, const null_buffers&, + const endpoint_type&, socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Receive a datagram with the endpoint of the sender. Returns the number of + // bytes received. + template <typename MutableBufferSequence> + std::size_t receive_from(implementation_type&, const MutableBufferSequence&, + endpoint_type&, socket_base::message_flags, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Wait until data can be received without blocking. + std::size_t receive_from(implementation_type&, const null_buffers&, + endpoint_type&, socket_base::message_flags, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous receive. The buffer for the data being received and + // the sender_endpoint object must both be valid for the lifetime of the + // asynchronous operation. + template <typename MutableBufferSequence, typename Handler> + void async_receive_from(implementation_type&, + const MutableBufferSequence&, endpoint_type&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Wait until data can be received without blocking. + template <typename Handler> + void async_receive_from(implementation_type&, + const null_buffers&, endpoint_type&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.post(detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Accept a new connection. + template <typename Socket> + boost::system::error_code accept(implementation_type&, + Socket&, endpoint_type*, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Start an asynchronous accept. The peer and peer_endpoint objects + // must be valid until the accept's handler is invoked. + template <typename Socket, typename Handler> + void async_accept(implementation_type&, Socket&, + endpoint_type*, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + io_service_.post(detail::bind_handler(handler, ec)); + } + + // Connect the socket to the specified endpoint. + boost::system::error_code connect(implementation_type&, + const endpoint_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Start an asynchronous connect. + template <typename Handler> + void async_connect(implementation_type&, + const endpoint_type&, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + io_service_.post(detail::bind_handler(handler, ec)); + } + +private: + boost::asio::io_service& io_service_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp index 3032896..201eefe 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp @@ -1,11 +1,11 @@ // // detail/null_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -54,9 +54,9 @@ struct null_static_mutex } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp index 0212dbe..209ac23 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp @@ -1,11 +1,11 @@ // // detail/null_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_THREAD_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -55,9 +55,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_THREAD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp index 07be3e6..a8f4773 100644 --- a/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp @@ -1,11 +1,11 @@ // // detail/null_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_NULL_TSS_PTR_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -62,9 +62,9 @@ private: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp index d315236..c2021a4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp @@ -1,11 +1,11 @@ // // detail/object_pool.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_OBJECT_POOL_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp index fcc27cf..df9f2ef 100644 --- a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp @@ -1,11 +1,11 @@ // // detail/old_win_sdk_compat.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Guess whether we are building against on old Platform SDK. #if !defined(IN6ADDR_ANY_INIT) #define BOOST_ASIO_HAS_OLD_WIN_SDK 1 #endif // !defined(IN6ADDR_ANY_INIT) @@ -208,9 +208,9 @@ struct addrinfo_emulation // Some SDKs (e.g. Windows CE) don't define IPPROTO_ICMPV6. #if !defined(IPPROTO_ICMPV6) # define IPPROTO_ICMPV6 58 #endif -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp index ad61910..2b586dd 100644 --- a/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp @@ -1,11 +1,11 @@ // // detail/op_queue.hpp // ~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_OP_QUEUE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/operation.hpp b/3rdParty/Boost/src/boost/asio/detail/operation.hpp index 99371a9..d67dfa0 100644 --- a/3rdParty/Boost/src/boost/asio/detail/operation.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/operation.hpp @@ -1,11 +1,11 @@ // // detail/operation.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_OPERATION_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp index 0aee2a2..02a70ae 100644 --- a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp @@ -1,11 +1,11 @@ // // detail/pipe_select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP @@ -14,13 +14,14 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) +#if !defined(BOOST_ASIO_WINDOWS) +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) #if !defined(__CYGWIN__) #if !defined(__SYMBIAN32__) #if !defined(BOOST_ASIO_HAS_EVENTFD) #include <boost/asio/detail/push_options.hpp> @@ -81,9 +82,10 @@ private: # include <boost/asio/detail/impl/pipe_select_interrupter.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_HAS_EVENTFD) #endif // !defined(__SYMBIAN32__) #endif // !defined(__CYGWIN__) -#endif // !defined(BOOST_WINDOWS) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) +#endif // !defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp b/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp index 6e78ddf..0dd9a45 100644 --- a/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp @@ -1,11 +1,11 @@ // // detail/pop_options.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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) // // No header guard @@ -92,7 +92,14 @@ // Must remain the last #elif since some other vendors (Metrowerks, for example) // also #define _MSC_VER # pragma warning (pop) # pragma pack (pop) +# if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# if defined(BOOST_ASIO_CLR_WORKAROUND) +# undef generic +# undef BOOST_ASIO_CLR_WORKAROUND +# endif +# endif + #endif diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp index b77f384..9b633af 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp @@ -1,11 +1,11 @@ // // detail/posix_event.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_EVENT_HPP @@ -14,16 +14,16 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) -#include <boost/assert.hpp> #include <pthread.h> +#include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { @@ -39,62 +39,90 @@ public: // Destructor. ~posix_event() { ::pthread_cond_destroy(&cond_); } - // Signal the event. + // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock& lock) { - BOOST_ASSERT(lock.locked()); + this->signal_all(lock); + } + + // Signal all waiters. + template <typename Lock> + void signal_all(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); (void)lock; - signalled_ = true; - ::pthread_cond_signal(&cond_); // Ignore EINVAL. + state_ |= 1; + ::pthread_cond_broadcast(&cond_); // Ignore EINVAL. } - // Signal the event and unlock the mutex. + // Unlock the mutex and signal one waiter. template <typename Lock> - void signal_and_unlock(Lock& lock) + void unlock_and_signal_one(Lock& lock) { - BOOST_ASSERT(lock.locked()); - signalled_ = true; + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + bool have_waiters = (state_ > 1); lock.unlock(); - ::pthread_cond_signal(&cond_); // Ignore EINVAL. + if (have_waiters) + ::pthread_cond_signal(&cond_); // Ignore EINVAL. + } + + // If there's a waiter, unlock the mutex and signal it. + template <typename Lock> + bool maybe_unlock_and_signal_one(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + if (state_ > 1) + { + lock.unlock(); + ::pthread_cond_signal(&cond_); // Ignore EINVAL. + return true; + } + return false; } // Reset the event. template <typename Lock> void clear(Lock& lock) { - BOOST_ASSERT(lock.locked()); + BOOST_ASIO_ASSERT(lock.locked()); (void)lock; - signalled_ = false; + state_ &= ~std::size_t(1); } // Wait for the event to become signalled. template <typename Lock> void wait(Lock& lock) { - BOOST_ASSERT(lock.locked()); - while (!signalled_) + BOOST_ASIO_ASSERT(lock.locked()); + while ((state_ & 1) == 0) + { + state_ += 2; ::pthread_cond_wait(&cond_, &lock.mutex().mutex_); // Ignore EINVAL. + state_ -= 2; + } } private: ::pthread_cond_t cond_; - bool signalled_; + std::size_t state_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_event.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_EVENT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp index f6476e6..267c983 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp @@ -1,11 +1,11 @@ // // detail/posix_fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP @@ -14,16 +14,19 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(__CYGWIN__) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <cstring> #include <boost/asio/detail/noncopyable.hpp> +#include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { @@ -55,12 +58,26 @@ public: FD_SET(descriptor, &fd_set_); return true; } return false; } + void set(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops) + { + reactor_op_queue<socket_type>::iterator i = operations.begin(); + while (i != operations.end()) + { + reactor_op_queue<socket_type>::iterator op_iter = i++; + if (!set(op_iter->first)) + { + boost::system::error_code ec(error::fd_set_failure); + operations.cancel_operations(op_iter, ops, ec); + } + } + } + bool is_set(socket_type descriptor) const { return FD_ISSET(descriptor, &fd_set_) != 0; } operator fd_set*() @@ -70,20 +87,34 @@ public: socket_type max_descriptor() const { return max_descriptor_; } + void perform(reactor_op_queue<socket_type>& operations, + op_queue<operation>& ops) const + { + reactor_op_queue<socket_type>::iterator i = operations.begin(); + while (i != operations.end()) + { + reactor_op_queue<socket_type>::iterator op_iter = i++; + if (is_set(op_iter->first)) + operations.perform_operations(op_iter, ops); + } + } + private: mutable fd_set fd_set_; socket_type max_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(__CYGWIN__) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp index a456c2a..7db2231 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp @@ -1,11 +1,11 @@ // // detail/posix_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> @@ -70,9 +70,9 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp index 0347778..e069897 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp @@ -1,11 +1,11 @@ // // detail/posix_signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <csignal> #include <pthread.h> #include <signal.h> #include <boost/asio/detail/noncopyable.hpp> @@ -79,9 +79,9 @@ private: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp index a27d9d8..a9c278c 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp @@ -1,11 +1,11 @@ // // detail/posix_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> @@ -58,9 +58,9 @@ struct posix_static_mutex } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp index 44bf62c..cf40c9d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp @@ -1,11 +1,11 @@ // // detail/posix_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_THREAD_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> @@ -99,9 +99,9 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_thread.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_THREAD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp index 33ac502..10abe82 100644 --- a/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp @@ -1,11 +1,11 @@ // // detail/posix_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_POSIX_TSS_PTR_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#if defined(BOOST_ASIO_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> @@ -61,22 +61,21 @@ public: } private: // Thread-specific storage to allow unlocked access to determine whether a // thread is a member of the pool. pthread_key_t tss_key_; - }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_tss_ptr.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS) +#endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp index fef517d..ad72bfb 100644 --- a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp @@ -1,11 +1,11 @@ // // detail/push_options.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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) // // No header guard @@ -100,13 +100,15 @@ # pragma warning (disable:4103) # pragma warning (push) # pragma warning (disable:4127) # pragma warning (disable:4180) # pragma warning (disable:4244) # pragma warning (disable:4355) +# pragma warning (disable:4510) # pragma warning (disable:4512) +# pragma warning (disable:4610) # pragma warning (disable:4675) # if defined(_M_IX86) && defined(_Wp64) // The /Wp64 option is broken. If you want to check 64 bit portability, use a // 64 bit compiler! # pragma warning (disable:4311) # pragma warning (disable:4312) @@ -121,7 +123,16 @@ # pragma optimize ("g", off) # endif # if !defined(_MT) # error Multithreaded RTL must be selected. # endif // !defined(_MT) +# if defined(__cplusplus_cli) || defined(__cplusplus_winrt) +# if !defined(BOOST_ASIO_DISABLE_CLR_WORKAROUND) +# if !defined(generic) +# define generic cpp_generic +# define BOOST_ASIO_CLR_WORKAROUND +# endif +# endif +# endif + #endif diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp index 5efb24b..10b2f3f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp @@ -1,11 +1,11 @@ // // detail/reactive_descriptor_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP @@ -14,17 +14,19 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) -#include <boost/utility/addressof.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/descriptor_read_op.hpp> #include <boost/asio/detail/descriptor_write_op.hpp> #include <boost/asio/detail/fenced_block.hpp> @@ -183,45 +185,51 @@ public: } // Start an asynchronous write. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_write_some(implementation_type& impl, - const ConstBufferSequence& buffers, Handler handler) + const ConstBufferSequence& buffers, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef descriptor_write_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.descriptor_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some")); - start_op(impl, reactor::write_op, p.p, true, + start_op(impl, reactor::write_op, p.p, is_continuation, true, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::all_empty(buffers)); p.v = p.p = 0; } // Start an asynchronous wait until data can be written without blocking. template <typename Handler> void async_write_some(implementation_type& impl, - const null_buffers&, Handler handler) + const null_buffers&, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some(null_buffers)")); - start_op(impl, reactor::write_op, p.p, false, false); + start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Read some data from the stream. Returns the number of bytes read. template <typename MutableBufferSequence> size_t read_some(implementation_type& impl, @@ -245,52 +253,58 @@ public: } // Start an asynchronous read. The buffer for the data being read must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_read_some(implementation_type& impl, - const MutableBufferSequence& buffers, Handler handler) + const MutableBufferSequence& buffers, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef descriptor_read_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.descriptor_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some")); - start_op(impl, reactor::read_op, p.p, true, + start_op(impl, reactor::read_op, p.p, is_continuation, true, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::all_empty(buffers)); p.v = p.p = 0; } // Wait until data can be read without blocking. template <typename Handler> void async_read_some(implementation_type& impl, - const null_buffers&, Handler handler) + const null_buffers&, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some(null_buffers)")); - start_op(impl, reactor::read_op, p.p, false, false); + start_op(impl, reactor::read_op, p.p, is_continuation, false, false); p.v = p.p = 0; } private: // Start the asynchronous operation. BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type, - reactor_op* op, bool is_non_blocking, bool noop); + reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop); // The selector that performs event demultiplexing for the service. reactor& reactor_; }; } // namespace detail @@ -300,9 +314,11 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_descriptor_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp index 3881e96..39aaa60 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_null_buffers_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/push_options.hpp> @@ -49,25 +49,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp index a32088f..86d8300 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp @@ -1,11 +1,11 @@ // // detail/reactive_serial_port_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -16,13 +16,13 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_SERIAL_PORT) -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <string> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/serial_port_base.hpp> #include <boost/asio/detail/descriptor_ops.hpp> @@ -155,13 +155,13 @@ public: } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_write_some(implementation_type& impl, - const ConstBufferSequence& buffers, Handler handler) + const ConstBufferSequence& buffers, Handler& handler) { descriptor_service_.async_write_some(impl, buffers, handler); } // Read some data. Returns the number of bytes received. template <typename MutableBufferSequence> @@ -172,13 +172,13 @@ public: } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_read_some(implementation_type& impl, - const MutableBufferSequence& buffers, Handler handler) + const MutableBufferSequence& buffers, Handler& handler) { descriptor_service_.async_read_some(impl, buffers, handler); } private: // Function pointer type for storing a serial port option. @@ -227,10 +227,10 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_serial_port_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp index d80bdea..93ece02 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_accept_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -55,13 +55,13 @@ public: socket_type new_socket = invalid_socket; bool result = socket_ops::non_blocking_accept(o->socket_, o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0, o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket); // On success, assign new connection to peer socket object. - if (new_socket >= 0) + if (new_socket != invalid_socket) { socket_holder new_socket_holder(new_socket); if (o->peer_endpoint_) o->peer_endpoint_->resize(addrlen); if (!o->peer_.assign(o->protocol_, new_socket, o->ec_)) new_socket_holder.release(); @@ -97,25 +97,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp index 6463a03..254c9f4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_connect_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -67,25 +67,25 @@ public: const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_connect_op* o (static_cast<reactive_socket_connect_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp index 8814c1e..d6a124d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_recv_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -84,25 +84,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp index a6b37e4..ef806bc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_recvfrom_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -94,25 +94,25 @@ public: const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_recvfrom_op* o( static_cast<reactive_socket_recvfrom_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp index e9c2483..b6e0e3a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_recvmsg_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/socket_base.hpp> @@ -86,25 +86,25 @@ public: const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_recvmsg_op* o( static_cast<reactive_socket_recvmsg_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp index b1c3f65..a3a4424 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_send_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -81,25 +81,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp index 08396a0..ffa1e68 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_sendto_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP @@ -13,13 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -84,25 +84,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp index f66e25f..35678ae 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP @@ -16,17 +16,17 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if !defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/reactive_null_buffers_op.hpp> #include <boost/asio/detail/reactive_socket_accept_op.hpp> #include <boost/asio/detail/reactive_socket_connect_op.hpp> #include <boost/asio/detail/reactive_socket_recvfrom_op.hpp> @@ -96,12 +96,24 @@ public: this->base_move_assign(impl, other_service, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); } + // Move-construct a new socket implementation from another protocol type. + template <typename Protocol1> + void converting_move_construct(implementation_type& impl, + typename reactive_socket_service< + Protocol1>::implementation_type& other_impl) + { + this->base_move_construct(impl, other_impl); + + impl.protocol_ = protocol_type(other_impl.protocol_); + other_impl.protocol_ = typename Protocol1::endpoint().protocol(); + } + // Open a new socket implementation. boost::system::error_code open(implementation_type& impl, const protocol_type& protocol, boost::system::error_code& ec) { if (!do_open(impl, protocol.family(), protocol.type(), protocol.protocol(), ec)) @@ -212,44 +224,50 @@ public: // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, socket_base::message_flags flags, - Handler handler) + Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_sendto_op<ConstBufferSequence, endpoint_type, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to")); - start_op(impl, reactor::write_op, p.p, true, false); + start_op(impl, reactor::write_op, p.p, is_continuation, true, false); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler> void async_send_to(implementation_type& impl, const null_buffers&, - const endpoint_type&, socket_base::message_flags, Handler handler) + const endpoint_type&, socket_base::message_flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to(null_buffers)")); - start_op(impl, reactor::write_op, p.p, false, false); + start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive a datagram with the endpoint of the sender. Returns the number of // bytes received. template <typename MutableBufferSequence> @@ -289,43 +307,49 @@ public: // Start an asynchronous receive. The buffer for the data being received and // the sender_endpoint object must both be valid for the lifetime of the // asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endpoint, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recvfrom_op<MutableBufferSequence, endpoint_type, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; int protocol = impl.protocol_.type(); p.p = new (p.v) op(impl.socket_, protocol, buffers, sender_endpoint, flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, true, false); + p.p, is_continuation, true, false); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler> void async_receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from(null_buffers)")); @@ -333,13 +357,13 @@ public: // Reset endpoint since it can be given no sensible value at this time. sender_endpoint = endpoint_type(); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, false, false); + p.p, is_continuation, false, false); p.v = p.p = 0; } // Accept a new connection. template <typename Socket> boost::system::error_code accept(implementation_type& impl, @@ -370,25 +394,28 @@ public: } // Start an asynchronous accept. The peer and peer_endpoint objects // must be valid until the accept's handler is invoked. template <typename Socket, typename Handler> void async_accept(implementation_type& impl, Socket& peer, - endpoint_type* peer_endpoint, Handler handler) + endpoint_type* peer_endpoint, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_accept_op<Socket, Protocol, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, impl.state_, peer, impl.protocol_, peer_endpoint, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept")); - start_accept_op(impl, p.p, peer.is_open()); + start_accept_op(impl, p.p, is_continuation, peer.is_open()); p.v = p.p = 0; } // Connect the socket to the specified endpoint. boost::system::error_code connect(implementation_type& impl, const endpoint_type& peer_endpoint, boost::system::error_code& ec) @@ -398,24 +425,28 @@ public: return ec; } // Start an asynchronous connect. template <typename Handler> void async_connect(implementation_type& impl, - const endpoint_type& peer_endpoint, Handler handler) + const endpoint_type& peer_endpoint, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_connect_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect")); - start_connect_op(impl, p.p, peer_endpoint.data(), peer_endpoint.size()); + start_connect_op(impl, p.p, is_continuation, + peer_endpoint.data(), peer_endpoint.size()); p.v = p.p = 0; } }; } // namespace detail } // namespace asio diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp index 0180435..aeaf4f4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp @@ -1,11 +1,11 @@ // // detail/reactive_socket_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP @@ -14,19 +14,20 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_ASIO_HAS_IOCP) +#if !defined(BOOST_ASIO_HAS_IOCP) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) -#include <boost/utility/addressof.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/reactive_null_buffers_op.hpp> #include <boost/asio/detail/reactive_socket_recv_op.hpp> #include <boost/asio/detail/reactive_socket_recvmsg_op.hpp> #include <boost/asio/detail/reactive_socket_send_op.hpp> #include <boost/asio/detail/reactor.hpp> @@ -195,46 +196,52 @@ public: // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_send(base_implementation_type& impl, const ConstBufferSequence& buffers, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_send_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, buffers, flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send")); - start_op(impl, reactor::write_op, p.p, true, + start_op(impl, reactor::write_op, p.p, is_continuation, true, ((impl.state_ & socket_ops::stream_oriented) && buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::all_empty(buffers))); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler> void async_send(base_implementation_type& impl, const null_buffers&, - socket_base::message_flags, Handler handler) + socket_base::message_flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send(null_buffers)")); - start_op(impl, reactor::write_op, p.p, false, false); + start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive some data from the peer. Returns the number of bytes received. template <typename MutableBufferSequence> size_t receive(base_implementation_type& impl, @@ -260,52 +267,59 @@ public: // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive(base_implementation_type& impl, const MutableBufferSequence& buffers, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, (flags & socket_base::message_out_of_band) == 0, + p.p, is_continuation, + (flags & socket_base::message_out_of_band) == 0, ((impl.state_ & socket_ops::stream_oriented) && buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::all_empty(buffers))); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler> void async_receive(base_implementation_type& impl, const null_buffers&, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive(null_buffers)")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, false, false); + p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive some data with associated flags. Returns the number of bytes // received. template <typename MutableBufferSequence> @@ -338,40 +352,47 @@ public: // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, - socket_base::message_flags& out_flags, Handler handler) + socket_base::message_flags& out_flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_with_flags")); start_op(impl, (in_flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, (in_flags & socket_base::message_out_of_band) == 0, false); + p.p, is_continuation, + (in_flags & socket_base::message_out_of_band) == 0, false); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler> void async_receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags in_flags, - socket_base::message_flags& out_flags, Handler handler) + socket_base::message_flags& out_flags, Handler& handler) { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_with_flags(null_buffers)")); @@ -380,13 +401,13 @@ public: // performing a null_buffers operation. out_flags = 0; start_op(impl, (in_flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, - p.p, false, false); + p.p, is_continuation, false, false); p.v = p.p = 0; } protected: // Open a new socket implementation. BOOST_ASIO_DECL boost::system::error_code do_open( @@ -397,21 +418,22 @@ protected: BOOST_ASIO_DECL boost::system::error_code do_assign( base_implementation_type& impl, int type, const native_handle_type& native_socket, boost::system::error_code& ec); // Start the asynchronous read or write operation. BOOST_ASIO_DECL void start_op(base_implementation_type& impl, int op_type, - reactor_op* op, bool is_non_blocking, bool noop); + reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop); // Start the asynchronous accept operation. BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl, - reactor_op* op, bool peer_is_open); + reactor_op* op, bool is_continuation, bool peer_is_open); // Start the asynchronous connect operation. BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl, - reactor_op* op, const socket_addr_type* addr, size_t addrlen); + reactor_op* op, bool is_continuation, + const socket_addr_type* addr, size_t addrlen); // The selector that performs event demultiplexing for the service. reactor& reactor_; }; } // namespace detail @@ -422,8 +444,9 @@ protected: #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_socket_service_base.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_HAS_IOCP) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor.hpp index 7e28679..e183793 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactor.hpp @@ -1,11 +1,11 @@ // // detail/reactor.hpp // ~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTOR_HPP @@ -20,11 +20,13 @@ #if defined(BOOST_ASIO_HAS_EPOLL) # include <boost/asio/detail/epoll_reactor.hpp> #elif defined(BOOST_ASIO_HAS_KQUEUE) # include <boost/asio/detail/kqueue_reactor.hpp> #elif defined(BOOST_ASIO_HAS_DEV_POLL) # include <boost/asio/detail/dev_poll_reactor.hpp> +#elif defined(BOOST_ASIO_WINDOWS_RUNTIME) +# include <boost/asio/detail/null_reactor.hpp> #else # include <boost/asio/detail/select_reactor.hpp> #endif #endif // BOOST_ASIO_DETAIL_REACTOR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp index 7ea119e..80f4032 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp @@ -1,11 +1,11 @@ // // detail/reactor_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTOR_FWD_HPP @@ -14,38 +14,28 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_ASIO_HAS_IOCP) -# include <boost/asio/detail/select_reactor_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_EPOLL) -# include <boost/asio/detail/epoll_reactor_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_KQUEUE) -# include <boost/asio/detail/kqueue_reactor_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_DEV_POLL) -# include <boost/asio/detail/dev_poll_reactor_fwd.hpp> -#else -# include <boost/asio/detail/select_reactor_fwd.hpp> -#endif - namespace boost { namespace asio { namespace detail { -#if defined(BOOST_ASIO_HAS_IOCP) -typedef select_reactor reactor; +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +typedef class null_reactor reactor; +#elif defined(BOOST_ASIO_HAS_IOCP) +typedef class select_reactor reactor; #elif defined(BOOST_ASIO_HAS_EPOLL) -typedef epoll_reactor reactor; +typedef class epoll_reactor reactor; #elif defined(BOOST_ASIO_HAS_KQUEUE) -typedef kqueue_reactor reactor; +typedef class kqueue_reactor reactor; #elif defined(BOOST_ASIO_HAS_DEV_POLL) -typedef dev_poll_reactor reactor; +typedef class dev_poll_reactor reactor; #else -typedef select_reactor reactor; +typedef class select_reactor reactor; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp index 3b8e7f9..959badd 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp @@ -1,11 +1,11 @@ // // detail/reactor_op.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTOR_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp index 692a2ee..effe771 100644 --- a/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp @@ -1,11 +1,11 @@ // // detail/reactor_op_queue.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP @@ -30,170 +30,138 @@ namespace detail { template <typename Descriptor> class reactor_op_queue : private noncopyable { public: + typedef Descriptor key_type; + + struct mapped_type : op_queue<reactor_op> + { + mapped_type() {} + mapped_type(const mapped_type&) {} + void operator=(const mapped_type&) {} + }; + + typedef typename hash_map<key_type, mapped_type>::value_type value_type; + typedef typename hash_map<key_type, mapped_type>::iterator iterator; + // Constructor. reactor_op_queue() : operations_() { } + // Obtain iterators to all registered descriptors. + iterator begin() { return operations_.begin(); } + iterator end() { return operations_.end(); } + // Add a new operation to the queue. Returns true if this is the only // operation for the given descriptor, in which case the reactor's event // demultiplexing function call may need to be interrupted and restarted. bool enqueue_operation(Descriptor descriptor, reactor_op* op) { - typedef typename operations_map::iterator iterator; - typedef typename operations_map::value_type value_type; std::pair<iterator, bool> entry = - operations_.insert(value_type(descriptor, operations())); - entry.first->second.op_queue_.push(op); + operations_.insert(value_type(descriptor, mapped_type())); + entry.first->second.push(op); return entry.second; } - // Cancel all operations associated with the descriptor. Any operations - // pending for the descriptor will be notified that they have been cancelled - // next time perform_cancellations is called. Returns true if any operations - // were cancelled, in which case the reactor's event demultiplexing function - // may need to be interrupted and restarted. - bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops, + // Cancel all operations associated with the descriptor identified by the + // supplied iterator. Any operations pending for the descriptor will be + // cancelled. Returns true if any operations were cancelled, in which case + // the reactor's event demultiplexing function may need to be interrupted and + // restarted. + bool cancel_operations(iterator i, op_queue<operation>& ops, const boost::system::error_code& ec = boost::asio::error::operation_aborted) { - typename operations_map::iterator i = operations_.find(descriptor); if (i != operations_.end()) { - while (reactor_op* op = i->second.op_queue_.front()) + while (reactor_op* op = i->second.front()) { op->ec_ = ec; - i->second.op_queue_.pop(); + i->second.pop(); ops.push(op); } operations_.erase(i); return true; } return false; } + // Cancel all operations associated with the descriptor. Any operations + // pending for the descriptor will be cancelled. Returns true if any + // operations were cancelled, in which case the reactor's event + // demultiplexing function may need to be interrupted and restarted. + bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops, + const boost::system::error_code& ec = + boost::asio::error::operation_aborted) + { + return this->cancel_operations(operations_.find(descriptor), ops, ec); + } + // Whether there are no operations in the queue. bool empty() const { return operations_.empty(); } // Determine whether there are any operations associated with the descriptor. bool has_operation(Descriptor descriptor) const { return operations_.find(descriptor) != operations_.end(); } - // Perform the operations corresponding to the descriptor. Returns true if - // there are still unfinished operations queued for the descriptor. - bool perform_operations(Descriptor descriptor, op_queue<operation>& ops) + // Perform the operations corresponding to the descriptor identified by the + // supplied iterator. Returns true if there are still unfinished operations + // queued for the descriptor. + bool perform_operations(iterator i, op_queue<operation>& ops) { - typename operations_map::iterator i = operations_.find(descriptor); if (i != operations_.end()) { - while (reactor_op* op = i->second.op_queue_.front()) + while (reactor_op* op = i->second.front()) { if (op->perform()) { - i->second.op_queue_.pop(); + i->second.pop(); ops.push(op); } else { return true; } } operations_.erase(i); } return false; } - // Fill a descriptor set with the descriptors corresponding to each active - // operation. The op_queue is used only when descriptors fail to be added to - // the descriptor set. - template <typename Descriptor_Set> - void get_descriptors(Descriptor_Set& descriptors, op_queue<operation>& ops) - { - typename operations_map::iterator i = operations_.begin(); - while (i != operations_.end()) - { - Descriptor descriptor = i->first; - ++i; - if (!descriptors.set(descriptor)) - { - boost::system::error_code ec(error::fd_set_failure); - cancel_operations(descriptor, ops, ec); - } - } - } - - // Perform the operations corresponding to the ready file descriptors - // contained in the given descriptor set. - template <typename Descriptor_Set> - void perform_operations_for_descriptors( - const Descriptor_Set& descriptors, op_queue<operation>& ops) + // Perform the operations corresponding to the descriptor. Returns true if + // there are still unfinished operations queued for the descriptor. + bool perform_operations(Descriptor descriptor, op_queue<operation>& ops) { - typename operations_map::iterator i = operations_.begin(); - while (i != operations_.end()) - { - typename operations_map::iterator op_iter = i++; - if (descriptors.is_set(op_iter->first)) - { - while (reactor_op* op = op_iter->second.op_queue_.front()) - { - if (op->perform()) - { - op_iter->second.op_queue_.pop(); - ops.push(op); - } - else - { - break; - } - } - - if (op_iter->second.op_queue_.empty()) - operations_.erase(op_iter); - } - } + return this->perform_operations(operations_.find(descriptor), ops); } // Get all operations owned by the queue. void get_all_operations(op_queue<operation>& ops) { - typename operations_map::iterator i = operations_.begin(); + iterator i = operations_.begin(); while (i != operations_.end()) { - typename operations_map::iterator op_iter = i++; - ops.push(op_iter->second.op_queue_); + iterator op_iter = i++; + ops.push(op_iter->second); operations_.erase(op_iter); } } private: - struct operations - { - operations() {} - operations(const operations&) {} - void operator=(const operations&) {} - - // The operations waiting on the desccriptor. - op_queue<reactor_op> op_queue_; - }; - - // The type for a map of operations. - typedef hash_map<Descriptor, operations> operations_map; - // The operations that are currently executing asynchronously. - operations_map operations_; + hash_map<key_type, mapped_type> operations_; }; } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp index 679146e..2b23b59 100644 --- a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp @@ -1,23 +1,25 @@ // // detail/regex_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_REGEX_FWD_HPP #define BOOST_ASIO_DETAIL_REGEX_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) +#if defined(BOOST_ASIO_HAS_BOOST_REGEX) + #include <boost/regex_fwd.hpp> #include <boost/regex/v4/match_flags.hpp> namespace boost { template <class BidiIterator> @@ -25,7 +27,9 @@ struct sub_match; template <class BidiIterator, class Allocator> class match_results; } // namespace boost +#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX) + #endif // BOOST_ASIO_DETAIL_REGEX_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp index e6c901a..28119bb 100644 --- a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp @@ -1,11 +1,11 @@ // // detail/resolve_endpoint_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP @@ -13,16 +13,16 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/ip/basic_resolver_iterator.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -55,13 +55,13 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the operation object. resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner && owner != &o->io_service_impl_) { // The operation is being run on the worker io_service. Time to perform // the resolver operation. @@ -89,13 +89,13 @@ public: // a sub-object of the handler may be the true owner of the memory // associated with the handler. Consequently, a local copy of the handler // is required to ensure that any owning sub-object remains valid until // after we have deallocated the memory here. detail::binder2<Handler, boost::system::error_code, iterator_type> handler(o->handler_, o->ec_, o->iter_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp index b640979..bed1c3c 100644 --- a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp @@ -1,11 +1,11 @@ // // detail/resolve_op.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_RESOLVE_OP_HPP @@ -13,17 +13,17 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#include <boost/utility/addressof.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/ip/basic_resolver_iterator.hpp> #include <boost/asio/ip/basic_resolver_query.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> @@ -63,13 +63,13 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the operation object. resolve_op* o(static_cast<resolve_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner && owner != &o->io_service_impl_) { // The operation is being run on the worker io_service. Time to perform // the resolver operation. @@ -94,13 +94,13 @@ public: // a sub-object of the handler may be the true owner of the memory // associated with the handler. Consequently, a local copy of the handler // is required to ensure that any owning sub-object remains valid until // after we have deallocated the memory here. detail::binder2<Handler, boost::system::error_code, iterator_type> handler(o->handler_, o->ec_, iterator_type()); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); if (o->addrinfo_) { handler.arg2_ = iterator_type::create(o->addrinfo_, o->query_.host_name(), o->query_.service_name()); } p.reset(); diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp index 8225844..4ba295d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp @@ -1,11 +1,11 @@ // // detail/resolver_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_RESOLVER_SERVICE_HPP @@ -13,14 +13,18 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> + +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #include <boost/asio/ip/basic_resolver_iterator.hpp> #include <boost/asio/ip/basic_resolver_query.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/resolve_endpoint_op.hpp> #include <boost/asio/detail/resolve_op.hpp> #include <boost/asio/detail/resolver_service_base.hpp> #include <boost/asio/detail/push_options.hpp> @@ -65,17 +69,17 @@ public: address_info, query.host_name(), query.service_name()); } // Asynchronously resolve a query to a list of entries. template <typename Handler> void async_resolve(implementation_type& impl, - const query_type& query, Handler handler) + const query_type& query, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef resolve_op<Protocol, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl, query, io_service_impl_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve")); @@ -97,17 +101,17 @@ public: endpoint, host_name, service_name); } // Asynchronously resolve an endpoint to a list of entries. template <typename Handler> void async_resolve(implementation_type& impl, - const endpoint_type& endpoint, Handler handler) + const endpoint_type& endpoint, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef resolve_endpoint_op<Protocol, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve")); @@ -119,7 +123,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp index 3a48d06..0c00896 100644 --- a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp @@ -1,11 +1,11 @@ // // detail/resolver_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP @@ -62,12 +62,13 @@ public: BOOST_ASIO_DECL void cancel(implementation_type& impl); protected: // Helper function to start an asynchronous resolve operation. BOOST_ASIO_DECL void start_resolve_op(operation* op); +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) // Helper class to perform exception-safe cleanup of addrinfo objects. class auto_addrinfo : private boost::asio::detail::noncopyable { public: explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai) @@ -86,12 +87,13 @@ protected: return ai_; } private: boost::asio::detail::addrinfo_type* ai_; }; +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) // Helper class to run the work io_service in a thread. class work_io_service_runner; // Start the work thread if it's not already running. BOOST_ASIO_DECL void start_work_thread(); diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp index a2e6fd4..848864e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp @@ -1,11 +1,11 @@ // // detail/scoped_lock.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SCOPED_LOCK_HPP @@ -26,14 +26,24 @@ namespace detail { // Helper class to lock and unlock a mutex automatically. template <typename Mutex> class scoped_lock : private noncopyable { public: + // Tag type used to distinguish constructors. + enum adopt_lock_t { adopt_lock }; + + // Constructor adopts a lock that is already held. + scoped_lock(Mutex& m, adopt_lock_t) + : mutex_(m), + locked_(true) + { + } + // Constructor acquires the lock. - scoped_lock(Mutex& m) + explicit scoped_lock(Mutex& m) : mutex_(m) { mutex_.lock(); locked_ = true; } diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp index 16436dd..5df78f7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp @@ -1,11 +1,11 @@ // // detail/scoped_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SCOPED_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp index 11a4967..4f802d1 100644 --- a/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp @@ -1,11 +1,11 @@ // // detail/select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SELECT_INTERRUPTER_HPP @@ -14,31 +14,35 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) # include <boost/asio/detail/socket_select_interrupter.hpp> #elif defined(BOOST_ASIO_HAS_EVENTFD) # include <boost/asio/detail/eventfd_select_interrupter.hpp> #else # include <boost/asio/detail/pipe_select_interrupter.hpp> #endif namespace boost { namespace asio { namespace detail { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) typedef socket_select_interrupter select_interrupter; #elif defined(BOOST_ASIO_HAS_EVENTFD) typedef eventfd_select_interrupter select_interrupter; #else typedef pipe_select_interrupter select_interrupter; #endif } // namespace detail } // namespace asio } // namespace boost +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #endif // BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp index a434546..6d3b243 100644 --- a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp @@ -1,11 +1,11 @@ // // detail/select_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SELECT_REACTOR_HPP @@ -17,26 +17,25 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) \ || (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ - && !defined(BOOST_ASIO_HAS_KQUEUE)) + && !defined(BOOST_ASIO_HAS_KQUEUE) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) -#include <boost/limits.hpp> #include <cstddef> #include <boost/asio/detail/fd_set_adapter.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/select_interrupter.hpp> -#include <boost/asio/detail/select_reactor_fwd.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> -#include <boost/asio/detail/timer_queue_fwd.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/io_service.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/thread.hpp> @@ -49,19 +48,19 @@ namespace asio { namespace detail { class select_reactor : public boost::asio::detail::service_base<select_reactor> { public: -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) enum op_types { read_op = 0, write_op = 1, except_op = 2, max_select_ops = 3, connect_op = 3, max_ops = 4 }; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) enum op_types { read_op = 0, write_op = 1, except_op = 2, max_select_ops = 3, connect_op = 1, max_ops = 3 }; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) // Per-descriptor data. struct per_descriptor_data { }; @@ -89,21 +88,21 @@ public: // success, system error code on failure. BOOST_ASIO_DECL int register_internal_descriptor( int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op); // Post a reactor operation for immediate completion. - void post_immediate_completion(reactor_op* op) + void post_immediate_completion(reactor_op* op, bool is_continuation) { - io_service_.post_immediate_completion(op); + io_service_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, - per_descriptor_data&, reactor_op* op, bool); + per_descriptor_data&, reactor_op* op, bool is_continuation, bool); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&); @@ -213,9 +212,10 @@ private: # include <boost/asio/detail/impl/select_reactor.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) // || (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) - // && !defined(BOOST_ASIO_HAS_KQUEUE)) + // && !defined(BOOST_ASIO_HAS_KQUEUE) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp deleted file mode 100644 index 1337969..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// detail/select_reactor_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP -#define BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -namespace boost { -namespace asio { -namespace detail { - -class select_reactor; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp index 458f271..bfd80fc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp @@ -1,11 +1,11 @@ // // detail/service_registry.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SERVICE_REGISTRY_HPP @@ -18,18 +18,12 @@ #include <boost/asio/detail/config.hpp> #include <typeinfo> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/io_service.hpp> -#if defined(BOOST_NO_TYPEID) -# if !defined(BOOST_ASIO_NO_TYPEID) -# define BOOST_ASIO_NO_TYPEID -# endif // !defined(BOOST_ASIO_NO_TYPEID) -#endif // defined(BOOST_NO_TYPEID) - #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp deleted file mode 100644 index 3157574..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// detail/service_registry_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_SERVICE_REGISTRY_FWD_HPP -#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -namespace boost { -namespace asio { -namespace detail { - -class service_registry; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // BOOST_ASIO_DETAIL_SERVICE_REGISTRY_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp index 5f0da22..3c79f61 100644 --- a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp @@ -1,11 +1,11 @@ // // detail/shared_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SHARED_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp index fe859b4..ad6baba 100644 --- a/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp @@ -1,11 +1,11 @@ // // detail/signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SIGNAL_BLOCKER_HPP @@ -14,29 +14,31 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) \ - || defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) +#if !defined(BOOST_ASIO_HAS_THREADS) || defined(BOOST_ASIO_WINDOWS) \ + || defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + || defined(__CYGWIN__) || defined(__SYMBIAN32__) # include <boost/asio/detail/null_signal_blocker.hpp> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_signal_blocker.hpp> #else # error Only Windows and POSIX are supported! #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) \ - || defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__) +#if !defined(BOOST_ASIO_HAS_THREADS) || defined(BOOST_ASIO_WINDOWS) \ + || defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + || defined(__CYGWIN__) || defined(__SYMBIAN32__) typedef null_signal_blocker signal_blocker; -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_signal_blocker signal_blocker; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp index bd1c727..32ce844 100644 --- a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp @@ -1,11 +1,11 @@ // // detail/signal_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SIGNAL_HANDLER_HPP @@ -13,12 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/signal_op.hpp> #include <boost/asio/detail/push_options.hpp> @@ -42,25 +43,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. signal_handler* h(static_cast<signal_handler*>(base)); - ptr p = { boost::addressof(h->handler_), h, h }; + ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, int> handler(h->handler_, h->ec_, h->signal_number_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp index e038a88..0dc6558 100644 --- a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp @@ -1,11 +1,11 @@ // // detail/signal_init.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SIGNAL_INIT_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <csignal> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -41,9 +41,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp index 706691b..e75d412 100644 --- a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp @@ -1,11 +1,11 @@ // // detail/signal_op.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SIGNAL_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp index afa67fe..9949f04 100644 --- a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp @@ -1,11 +1,11 @@ // // detail/signal_set_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP @@ -18,21 +18,22 @@ #include <boost/asio/detail/config.hpp> #include <cstddef> #include <signal.h> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/signal_handler.hpp> #include <boost/asio/detail/signal_op.hpp> #include <boost/asio/detail/socket_types.hpp> -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) # include <boost/asio/detail/reactor.hpp> -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -42,13 +43,13 @@ enum { max_signal_number = NSIG }; #else enum { max_signal_number = 128 }; #endif extern BOOST_ASIO_DECL struct signal_state* get_signal_state(); -extern "C" BOOST_ASIO_DECL void asio_signal_handler(int signal_number); +extern "C" BOOST_ASIO_DECL void boost_asio_signal_handler(int signal_number); class signal_set_service { public: // Type used for tracking an individual signal registration. class registration @@ -141,17 +142,17 @@ public: // Cancel all operations associated with the signal set. BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec); // Start an asynchronous operation to wait for a signal to be delivered. template <typename Handler> - void async_wait(implementation_type& impl, Handler handler) + void async_wait(implementation_type& impl, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef signal_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "signal_set", &impl, "async_wait")); @@ -178,22 +179,26 @@ private: // Helper function to start a wait operation. BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op); // The io_service instance used for dispatching handlers. io_service_impl& io_service_; -#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#if !defined(BOOST_ASIO_WINDOWS) \ + && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ + && !defined(__CYGWIN__) // The type used for registering for pipe reactor notifications. class pipe_read_op; // The reactor used for waiting for pipe readiness. reactor& reactor_; // The per-descriptor reactor data used for the pipe. reactor::per_descriptor_data reactor_data_; -#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) +#endif // !defined(BOOST_ASIO_WINDOWS) + // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) + // && !defined(__CYGWIN__) // A mapping from signal number to the registered signal sets. registration* registrations_[max_signal_number]; // Pointers to adjacent services in linked list. signal_set_service* next_; diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp index d299859..81f4142 100644 --- a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp @@ -1,11 +1,11 @@ // // detail/socket_holder.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_HOLDER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp index b353316..04a28ef 100644 --- a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp @@ -1,11 +1,11 @@ // // detail/socket_ops.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_OPS_HPP @@ -60,12 +60,14 @@ enum typedef unsigned char state_type; struct noop_deleter { void operator()(void*) {} }; typedef shared_ptr<void> shared_cancel_token_type; typedef weak_ptr<void> weak_cancel_token_type; +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + BOOST_ASIO_DECL socket_type accept(socket_type s, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL socket_type sync_accept(socket_type s, state_type state, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); @@ -103,37 +105,44 @@ BOOST_ASIO_DECL int shutdown(socket_type s, BOOST_ASIO_DECL int connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL void sync_connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); -BOOST_ASIO_DECL bool non_blocking_connect( - socket_type s, boost::system::error_code& ec); +#if defined(BOOST_ASIO_HAS_IOCP) + +BOOST_ASIO_DECL void complete_iocp_connect(socket_type s, + boost::system::error_code& ec); + +#endif // defined(BOOST_ASIO_HAS_IOCP) + +BOOST_ASIO_DECL bool non_blocking_connect(socket_type s, + boost::system::error_code& ec); BOOST_ASIO_DECL int socketpair(int af, int type, int protocol, socket_type sv[2], boost::system::error_code& ec); BOOST_ASIO_DECL bool sockatmark(socket_type s, boost::system::error_code& ec); BOOST_ASIO_DECL size_t available(socket_type s, boost::system::error_code& ec); BOOST_ASIO_DECL int listen(socket_type s, int backlog, boost::system::error_code& ec); -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef WSABUF buf; -#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef iovec buf; -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) BOOST_ASIO_DECL void init_buf(buf& b, void* data, size_t size); BOOST_ASIO_DECL void init_buf(buf& b, const void* data, size_t size); -BOOST_ASIO_DECL int recv(socket_type s, buf* bufs, size_t count, int flags, - boost::system::error_code& ec); +BOOST_ASIO_DECL signed_size_type recv(socket_type s, buf* bufs, + size_t count, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) @@ -146,15 +155,15 @@ BOOST_ASIO_DECL void complete_iocp_recv(state_type state, BOOST_ASIO_DECL bool non_blocking_recv(socket_type s, buf* bufs, size_t count, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) -BOOST_ASIO_DECL int recvfrom(socket_type s, buf* bufs, size_t count, int flags, - socket_addr_type* addr, std::size_t* addrlen, - boost::system::error_code& ec); +BOOST_ASIO_DECL signed_size_type recvfrom(socket_type s, buf* bufs, + size_t count, int flags, socket_addr_type* addr, + std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) @@ -169,14 +178,15 @@ BOOST_ASIO_DECL bool non_blocking_recvfrom(socket_type s, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) -BOOST_ASIO_DECL int recvmsg(socket_type s, buf* bufs, size_t count, - int in_flags, int& out_flags, boost::system::error_code& ec); +BOOST_ASIO_DECL signed_size_type recvmsg(socket_type s, buf* bufs, + size_t count, int in_flags, int& out_flags, + boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recvmsg(socket_type s, state_type state, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) @@ -190,13 +200,13 @@ BOOST_ASIO_DECL void complete_iocp_recvmsg( BOOST_ASIO_DECL bool non_blocking_recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) -BOOST_ASIO_DECL int send(socket_type s, const buf* bufs, +BOOST_ASIO_DECL signed_size_type send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_send(socket_type s, state_type state, const buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec); @@ -211,15 +221,15 @@ BOOST_ASIO_DECL void complete_iocp_send( BOOST_ASIO_DECL bool non_blocking_send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) -BOOST_ASIO_DECL int sendto(socket_type s, const buf* bufs, size_t count, - int flags, const socket_addr_type* addr, std::size_t addrlen, - boost::system::error_code& ec); +BOOST_ASIO_DECL signed_size_type sendto(socket_type s, const buf* bufs, + size_t count, int flags, const socket_addr_type* addr, + std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_sendto(socket_type s, state_type state, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); #if !defined(BOOST_ASIO_HAS_IOCP) @@ -259,21 +269,25 @@ BOOST_ASIO_DECL int poll_read(socket_type s, BOOST_ASIO_DECL int poll_write(socket_type s, state_type state, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_connect(socket_type s, boost::system::error_code& ec); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + BOOST_ASIO_DECL const char* inet_ntop(int af, const void* src, char* dest, size_t length, unsigned long scope_id, boost::system::error_code& ec); BOOST_ASIO_DECL int inet_pton(int af, const char* src, void* dest, unsigned long* scope_id, boost::system::error_code& ec); BOOST_ASIO_DECL int gethostname(char* name, int namelen, boost::system::error_code& ec); +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + BOOST_ASIO_DECL boost::system::error_code getaddrinfo(const char* host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec); BOOST_ASIO_DECL boost::system::error_code background_getaddrinfo( const weak_cancel_token_type& cancel_token, const char* host, @@ -295,12 +309,14 @@ BOOST_ASIO_DECL boost::system::error_code sync_getnameinfo( BOOST_ASIO_DECL boost::system::error_code background_getnameinfo( const weak_cancel_token_type& cancel_token, const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int sock_type, boost::system::error_code& ec); +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + BOOST_ASIO_DECL u_long_type network_to_host_long(u_long_type value); BOOST_ASIO_DECL u_long_type host_to_network_long(u_long_type value); BOOST_ASIO_DECL u_short_type network_to_host_short(u_short_type value); diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp index 5d3a514..2fe5ee4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp @@ -1,11 +1,11 @@ // // detail/socket_option.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_OPTION_HPP @@ -15,15 +15,14 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <stdexcept> -#include <boost/config.hpp> -#include <boost/throw_exception.hpp> #include <boost/asio/detail/socket_types.hpp> +#include <boost/asio/detail/throw_exception.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -120,13 +119,13 @@ public: break; case sizeof(value_): break; default: { std::length_error ex("boolean socket option resize"); - boost::throw_exception(ex); + boost::asio::detail::throw_exception(ex); } } } private: int value_; @@ -201,13 +200,13 @@ public: template <typename Protocol> void resize(const Protocol&, std::size_t s) { if (s != sizeof(value_)) { std::length_error ex("integer socket option resize"); - boost::throw_exception(ex); + boost::asio::detail::throw_exception(ex); } } private: int value_; }; @@ -225,13 +224,13 @@ public: } // Construct with specific option values. linger(bool e, int t) { enabled(e); - timeout BOOST_PREVENT_MACRO_SUBSTITUTION(t); + timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(t); } // Set the value for whether linger is enabled. void enabled(bool value) { value_.l_onoff = value ? 1 : 0; @@ -241,23 +240,23 @@ public: bool enabled() const { return value_.l_onoff != 0; } // Set the value for the linger timeout. - void timeout BOOST_PREVENT_MACRO_SUBSTITUTION(int value) + void timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(int value) { #if defined(WIN32) value_.l_linger = static_cast<u_short>(value); #else value_.l_linger = value; #endif } // Get the value for the linger timeout. - int timeout BOOST_PREVENT_MACRO_SUBSTITUTION() const + int timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION() const { return static_cast<int>(value_.l_linger); } // Get the level of the socket option. template <typename Protocol> @@ -272,20 +271,20 @@ public: { return Name; } // Get the address of the linger data. template <typename Protocol> - ::linger* data(const Protocol&) + detail::linger_type* data(const Protocol&) { return &value_; } // Get the address of the linger data. template <typename Protocol> - const ::linger* data(const Protocol&) const + const detail::linger_type* data(const Protocol&) const { return &value_; } // Get the size of the linger data. template <typename Protocol> @@ -298,18 +297,18 @@ public: template <typename Protocol> void resize(const Protocol&, std::size_t s) { if (s != sizeof(value_)) { std::length_error ex("linger socket option resize"); - boost::throw_exception(ex); + boost::asio::detail::throw_exception(ex); } } private: - ::linger value_; + detail::linger_type value_; }; } // namespace socket_option } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp index eb8c7d0..38f140d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp @@ -1,11 +1,11 @@ // // detail/socket_select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP @@ -14,13 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) \ +#if !defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#if defined(BOOST_ASIO_WINDOWS) \ || defined(__CYGWIN__) \ || defined(__SYMBIAN32__) #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> @@ -79,11 +81,13 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/socket_select_interrupter.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) // || defined(__CYGWIN__) // || defined(__SYMBIAN32__) +#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) + #endif // BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp index 3754592..29e4739 100644 --- a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp @@ -1,11 +1,11 @@ // // detail/socket_types.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOCKET_TYPES_HPP @@ -14,23 +14,30 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +// Empty. +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) # if defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) # error WinSock.h has already been included # endif // defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) # if defined(__BORLANDC__) # include <stdlib.h> // Needed for __errno # if !defined(_WSPIAPI_H_) # define _WSPIAPI_H_ # define BOOST_ASIO_WSPIAPI_H_DEFINED # endif // !defined(_WSPIAPI_H_) # endif // defined(__BORLANDC__) +# if defined(WINAPI_FAMILY) +# if ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0) +# include <windows.h> +# endif // ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0) +# endif // defined(WINAPI_FAMILY) # include <winsock2.h> # include <ws2tcpip.h> # include <mswsock.h> # if defined(BOOST_ASIO_WSPIAPI_H_DEFINED) # undef _WSPIAPI_H_ # undef BOOST_ASIO_WSPIAPI_H_DEFINED @@ -78,13 +85,94 @@ #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +const int max_addr_v4_str_len = 256; +const int max_addr_v6_str_len = 256; +typedef unsigned __int32 u_long_type; +typedef unsigned __int16 u_short_type; +struct in4_addr_type { u_long_type s_addr; }; +struct in4_mreq_type { in4_addr_type imr_multiaddr, imr_interface; }; +struct in6_addr_type { unsigned char s6_addr[16]; }; +struct in6_mreq_type { in6_addr_type ipv6mr_multiaddr; + unsigned long ipv6mr_interface; }; +struct socket_addr_type { int sa_family; }; +struct sockaddr_in4_type { int sin_family; + in4_addr_type sin_addr; u_short_type sin_port; }; +struct sockaddr_in6_type { int sin6_family; + in6_addr_type sin6_addr; u_short_type sin6_port; + u_long_type sin6_flowinfo; u_long_type sin6_scope_id; }; +struct sockaddr_storage_type { int ss_family; + unsigned char ss_bytes[128 - sizeof(int)]; }; +struct addrinfo_type { int ai_flags; + int ai_family, ai_socktype, ai_protocol; + int ai_addrlen; const void* ai_addr; + const char* ai_canonname; addrinfo_type* ai_next; }; +struct linger_type { u_short_type l_onoff, l_linger; }; +typedef u_long_type ioctl_arg_type; +typedef int signed_size_type; +# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c +# define BOOST_ASIO_OS_DEF_AF_UNSPEC 0 +# define BOOST_ASIO_OS_DEF_AF_INET 2 +# define BOOST_ASIO_OS_DEF_AF_INET6 23 +# define BOOST_ASIO_OS_DEF_SOCK_STREAM 1 +# define BOOST_ASIO_OS_DEF_SOCK_DGRAM 2 +# define BOOST_ASIO_OS_DEF_SOCK_RAW 3 +# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET 5 +# define BOOST_ASIO_OS_DEF_IPPROTO_IP 0 +# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 41 +# define BOOST_ASIO_OS_DEF_IPPROTO_TCP 6 +# define BOOST_ASIO_OS_DEF_IPPROTO_UDP 17 +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP 1 +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 58 +# define BOOST_ASIO_OS_DEF_FIONBIO 1 +# define BOOST_ASIO_OS_DEF_FIONREAD 2 +# define BOOST_ASIO_OS_DEF_INADDR_ANY 0 +# define BOOST_ASIO_OS_DEF_MSG_OOB 0x1 +# define BOOST_ASIO_OS_DEF_MSG_PEEK 0x2 +# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE 0x4 +# define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported. +# define BOOST_ASIO_OS_DEF_SHUT_RD 0x0 +# define BOOST_ASIO_OS_DEF_SHUT_WR 0x1 +# define BOOST_ASIO_OS_DEF_SHUT_RDWR 0x2 +# define BOOST_ASIO_OS_DEF_SOMAXCONN 0x7fffffff +# define BOOST_ASIO_OS_DEF_SOL_SOCKET 0xffff +# define BOOST_ASIO_OS_DEF_SO_BROADCAST 0x20 +# define BOOST_ASIO_OS_DEF_SO_DEBUG 0x1 +# define BOOST_ASIO_OS_DEF_SO_DONTROUTE 0x10 +# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE 0x8 +# define BOOST_ASIO_OS_DEF_SO_LINGER 0x80 +# define BOOST_ASIO_OS_DEF_SO_SNDBUF 0x1001 +# define BOOST_ASIO_OS_DEF_SO_RCVBUF 0x1002 +# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT 0x1003 +# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT 0x1004 +# define BOOST_ASIO_OS_DEF_SO_REUSEADDR 0x4 +# define BOOST_ASIO_OS_DEF_TCP_NODELAY 0x1 +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF 2 +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL 3 +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP 4 +# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP 5 +# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP 6 +# define BOOST_ASIO_OS_DEF_IP_TTL 7 +# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS 4 +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF 9 +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS 10 +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP 11 +# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP 12 +# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP 13 +# define BOOST_ASIO_OS_DEF_AI_CANONNAME 0x2 +# define BOOST_ASIO_OS_DEF_AI_PASSIVE 0x1 +# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST 0x4 +# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0x8 +# define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0x800 +# define BOOST_ASIO_OS_DEF_AI_ALL 0x100 +# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0x400 +#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) typedef SOCKET socket_type; const SOCKET invalid_socket = INVALID_SOCKET; const int socket_error_retval = SOCKET_ERROR; const int max_addr_v4_str_len = 256; const int max_addr_v6_str_len = 256; typedef sockaddr socket_addr_type; @@ -101,22 +189,89 @@ typedef addrinfo_emulation addrinfo_type; typedef in6_addr in6_addr_type; typedef ipv6_mreq in6_mreq_type; typedef sockaddr_in6 sockaddr_in6_type; typedef sockaddr_storage sockaddr_storage_type; typedef addrinfo addrinfo_type; # endif +typedef ::linger linger_type; typedef unsigned long ioctl_arg_type; typedef u_long u_long_type; typedef u_short u_short_type; -const int shutdown_receive = SD_RECEIVE; -const int shutdown_send = SD_SEND; -const int shutdown_both = SD_BOTH; -const int message_peek = MSG_PEEK; -const int message_out_of_band = MSG_OOB; -const int message_do_not_route = MSG_DONTROUTE; -const int message_end_of_record = 0; // Not supported on Windows. +typedef int signed_size_type; +# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c +# define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC +# define BOOST_ASIO_OS_DEF_AF_INET AF_INET +# define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6 +# define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM +# define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM +# define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW +# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET +# define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP +# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6 +# define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP +# define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6 +# define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO +# define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD +# define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY +# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB +# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK +# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE +# define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported on Windows. +# define BOOST_ASIO_OS_DEF_SHUT_RD SD_RECEIVE +# define BOOST_ASIO_OS_DEF_SHUT_WR SD_SEND +# define BOOST_ASIO_OS_DEF_SHUT_RDWR SD_BOTH +# define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN +# define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET +# define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST +# define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG +# define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE +# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE +# define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER +# define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF +# define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF +# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT +# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT +# define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR +# define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP +# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP +# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP +# define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL +# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP +# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP +# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP +# define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME +# define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE +# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST +# if defined(AI_NUMERICSERV) +# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV +# else +# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0 +# endif +# if defined(AI_V4MAPPED) +# define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED +# else +# define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0 +# endif +# if defined(AI_ALL) +# define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL +# else +# define BOOST_ASIO_OS_DEF_AI_ALL 0 +# endif +# if defined(AI_ADDRCONFIG) +# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG +# else +# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0 +# endif # if defined (_WIN32_WINNT) const int max_iov_len = 64; # else const int max_iov_len = 16; # endif #else @@ -145,22 +300,95 @@ typedef sockaddr_in sockaddr_in4_type; typedef in6_addr in6_addr_type; typedef ipv6_mreq in6_mreq_type; typedef sockaddr_in6 sockaddr_in6_type; typedef sockaddr_storage sockaddr_storage_type; typedef sockaddr_un sockaddr_un_type; typedef addrinfo addrinfo_type; +typedef ::linger linger_type; typedef int ioctl_arg_type; typedef uint32_t u_long_type; typedef uint16_t u_short_type; -const int shutdown_receive = SHUT_RD; -const int shutdown_send = SHUT_WR; -const int shutdown_both = SHUT_RDWR; -const int message_peek = MSG_PEEK; -const int message_out_of_band = MSG_OOB; -const int message_do_not_route = MSG_DONTROUTE; -const int message_end_of_record = MSG_EOR; +#if defined(BOOST_ASIO_HAS_SSIZE_T) +typedef ssize_t signed_size_type; +#else // defined(BOOST_ASIO_HAS_SSIZE_T) +typedef int signed_size_type; +#endif // defined(BOOST_ASIO_HAS_SSIZE_T) +# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c +# define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC +# define BOOST_ASIO_OS_DEF_AF_INET AF_INET +# define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6 +# define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM +# define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM +# define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW +# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET +# define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP +# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6 +# define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP +# define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP +# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6 +# define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO +# define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD +# define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY +# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB +# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK +# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE +# define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR +# define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD +# define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR +# define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR +# define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN +# define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET +# define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST +# define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG +# define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE +# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE +# define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER +# define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF +# define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF +# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT +# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT +# define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR +# define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL +# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP +# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP +# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP +# define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL +# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS +# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP +# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP +# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP +# define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME +# define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE +# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST +# if defined(AI_NUMERICSERV) +# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV +# else +# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0 +# endif +// Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but +// does not implement them. Therefore they are specifically excluded here. +# if defined(AI_V4MAPPED) && !defined(__QNXNTO__) +# define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED +# else +# define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0 +# endif +# if defined(AI_ALL) && !defined(__QNXNTO__) +# define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL +# else +# define BOOST_ASIO_OS_DEF_AI_ALL 0 +# endif +# if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__) +# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG +# else +# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0 +# endif # if defined(IOV_MAX) const int max_iov_len = IOV_MAX; # else // POSIX platforms are not required to define IOV_MAX. const int max_iov_len = 16; # endif diff --git a/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp index ab6f730..9063bfc 100644 --- a/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/solaris_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_SOLARIS_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp index fbac3ed..cc005cb 100644 --- a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp @@ -1,11 +1,11 @@ // // detail/static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_STATIC_MUTEX_HPP @@ -14,35 +14,40 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) # include <boost/asio/detail/null_static_mutex.hpp> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_static_mutex.hpp> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_static_mutex.hpp> +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +# include <boost/asio/detail/std_static_mutex.hpp> #else # error Only Windows and POSIX are supported! #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) typedef null_static_mutex static_mutex; # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_NULL_STATIC_MUTEX_INIT -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) typedef win_static_mutex static_mutex; # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_WIN_STATIC_MUTEX_INIT -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_static_mutex static_mutex; # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT +#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) +typedef std_static_mutex static_mutex; +# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_STD_STATIC_MUTEX_INIT #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/std_event.hpp b/3rdParty/Boost/src/boost/asio/detail/std_event.hpp new file mode 100644 index 0000000..53390b8 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/std_event.hpp @@ -0,0 +1,178 @@ +// +// detail/std_event.hpp +// ~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_STD_EVENT_HPP +#define BOOST_ASIO_DETAIL_STD_EVENT_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#include <chrono> +#include <condition_variable> +#include <boost/asio/detail/assert.hpp> +#include <boost/asio/detail/noncopyable.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class std_event + : private noncopyable +{ +public: + // Constructor. + std_event() + : state_(0) + { + } + + // Destructor. + ~std_event() + { + } + + // Signal the event. (Retained for backward compatibility.) + template <typename Lock> + void signal(Lock& lock) + { + this->signal_all(lock); + } + + // Signal all waiters. + template <typename Lock> + void signal_all(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + (void)lock; + state_ |= 1; + cond_.notify_all(); + } + + // Unlock the mutex and signal one waiter. + template <typename Lock> + void unlock_and_signal_one(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + bool have_waiters = (state_ > 1); + lock.unlock(); + if (have_waiters) + cond_.notify_one(); + } + + // If there's a waiter, unlock the mutex and signal it. + template <typename Lock> + bool maybe_unlock_and_signal_one(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + if (state_ > 1) + { + lock.unlock(); + cond_.notify_one(); + return true; + } + return false; + } + + // Reset the event. + template <typename Lock> + void clear(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + (void)lock; + state_ &= ~std::size_t(1); + } + + // Wait for the event to become signalled. + template <typename Lock> + void wait(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + unique_lock_adapter u_lock(lock); + while ((state_ & 1) == 0) + { + waiter w(state_); + cond_.wait(u_lock.unique_lock_); + } + } + + // Timed wait for the event to become signalled. + template <typename Lock> + bool wait_for_usec(Lock& lock, long usec) + { + BOOST_ASIO_ASSERT(lock.locked()); + unique_lock_adapter u_lock(lock); + if ((state_ & 1) == 0) + { + waiter w(state_); + cond_.wait_for(u_lock.unique_lock_, std::chrono::microseconds(usec)); + } + return (state_ & 1) != 0; + } + +private: + // Helper class to temporarily adapt a scoped_lock into a unique_lock so that + // it can be passed to std::condition_variable::wait(). + struct unique_lock_adapter + { + template <typename Lock> + explicit unique_lock_adapter(Lock& lock) + : unique_lock_(lock.mutex().mutex_, std::adopt_lock) + { + } + + ~unique_lock_adapter() + { + unique_lock_.release(); + } + + std::unique_lock<std::mutex> unique_lock_; + }; + + // Helper to increment and decrement the state to track outstanding waiters. + class waiter + { + public: + explicit waiter(std::size_t& state) + : state_(state) + { + state_ += 2; + } + + ~waiter() + { + state_ -= 2; + } + + private: + std::size_t& state_; + }; + + std::condition_variable cond_; + std::size_t state_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#endif // BOOST_ASIO_DETAIL_STD_EVENT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp new file mode 100644 index 0000000..58cdc07 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp @@ -0,0 +1,75 @@ +// +// detail/std_mutex.hpp +// ~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_STD_MUTEX_HPP +#define BOOST_ASIO_DETAIL_STD_MUTEX_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#include <mutex> +#include <boost/asio/detail/noncopyable.hpp> +#include <boost/asio/detail/scoped_lock.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class std_event; + +class std_mutex + : private noncopyable +{ +public: + typedef boost::asio::detail::scoped_lock<std_mutex> scoped_lock; + + // Constructor. + std_mutex() + { + } + + // Destructor. + ~std_mutex() + { + } + + // Lock the mutex. + void lock() + { + mutex_.lock(); + } + + // Unlock the mutex. + void unlock() + { + mutex_.unlock(); + } + +private: + friend class std_event; + std::mutex mutex_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#endif // BOOST_ASIO_DETAIL_STD_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp new file mode 100644 index 0000000..68980ab --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp @@ -0,0 +1,83 @@ +// +// detail/std_static_mutex.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_STD_STATIC_MUTEX_HPP +#define BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#include <mutex> +#include <boost/asio/detail/noncopyable.hpp> +#include <boost/asio/detail/scoped_lock.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class std_event; + +class std_static_mutex + : private noncopyable +{ +public: + typedef boost::asio::detail::scoped_lock<std_static_mutex> scoped_lock; + + // Constructor. + std_static_mutex(int) + { + } + + // Destructor. + ~std_static_mutex() + { + } + + // Initialise the mutex. + void init() + { + // Nothing to do. + } + + // Lock the mutex. + void lock() + { + mutex_.lock(); + } + + // Unlock the mutex. + void unlock() + { + mutex_.unlock(); + } + +private: + friend class std_event; + std::mutex mutex_; +}; + +#define BOOST_ASIO_STD_STATIC_MUTEX_INIT 0 + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) + +#endif // BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp new file mode 100644 index 0000000..7dcb2fd --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp @@ -0,0 +1,67 @@ +// +// detail/std_thread.hpp +// ~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_STD_THREAD_HPP +#define BOOST_ASIO_DETAIL_STD_THREAD_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_THREAD) + +#include <thread> +#include <boost/asio/detail/noncopyable.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class std_thread + : private noncopyable +{ +public: + // Constructor. + template <typename Function> + std_thread(Function f, unsigned int = 0) + : thread_(f) + { + } + + // Destructor. + ~std_thread() + { + join(); + } + + // Wait for the thread to exit. + void join() + { + if (thread_.joinable()) + thread_.join(); + } + +private: + std::thread thread_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_HAS_STD_THREAD) + +#endif // BOOST_ASIO_DETAIL_STD_THREAD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp index 3a271b5..0e1dea8 100644 --- a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp @@ -1,11 +1,11 @@ // // detail/strand_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_STRAND_SERVICE_HPP @@ -83,25 +83,30 @@ public: // Construct a new strand implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Request the io_service to invoke the given handler. template <typename Handler> - void dispatch(implementation_type& impl, Handler handler); + void dispatch(implementation_type& impl, Handler& handler); // Request the io_service to invoke the given handler and return immediately. template <typename Handler> - void post(implementation_type& impl, Handler handler); + void post(implementation_type& impl, Handler& handler); + + // Determine whether the strand is running in the current thread. + BOOST_ASIO_DECL bool running_in_this_thread( + const implementation_type& impl) const; private: // Helper function to dispatch a handler. Returns true if the handler should // be dispatched immediately. BOOST_ASIO_DECL bool do_dispatch(implementation_type& impl, operation* op); // Helper fiunction to post a handler. - BOOST_ASIO_DECL void do_post(implementation_type& impl, operation* op); + BOOST_ASIO_DECL void do_post(implementation_type& impl, + operation* op, bool is_continuation); BOOST_ASIO_DECL static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred); // The io_service implementation used to post completions. diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp index e05c3a7..a30ea04 100644 --- a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp @@ -1,11 +1,11 @@ // // detail/task_io_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TASK_IO_SERVICE_HPP @@ -20,24 +20,26 @@ #if !defined(BOOST_ASIO_HAS_IOCP) #include <boost/system/error_code.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/detail/atomic_count.hpp> #include <boost/asio/detail/call_stack.hpp> +#include <boost/asio/detail/event.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_fwd.hpp> -#include <boost/asio/detail/task_io_service_fwd.hpp> #include <boost/asio/detail/task_io_service_operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { +struct task_io_service_thread_info; + class task_io_service : public boost::asio::detail::service_base<task_io_service> { public: typedef task_io_service_operation operation; @@ -91,75 +93,54 @@ public: { return thread_call_stack::contains(this) != 0; } // Request invocation of the given handler. template <typename Handler> - void dispatch(Handler handler); + void dispatch(Handler& handler); // Request invocation of the given handler and return immediately. template <typename Handler> - void post(Handler handler); + void post(Handler& handler); // Request invocation of the given operation and return immediately. Assumes // that work_started() has not yet been called for the operation. - BOOST_ASIO_DECL void post_immediate_completion(operation* op); + BOOST_ASIO_DECL void post_immediate_completion( + operation* op, bool is_continuation); // Request invocation of the given operation and return immediately. Assumes // that work_started() was previously called for the operation. BOOST_ASIO_DECL void post_deferred_completion(operation* op); // Request invocation of the given operations and return immediately. Assumes // that work_started() was previously called for each operation. BOOST_ASIO_DECL void post_deferred_completions(op_queue<operation>& ops); - // Request invocation of the given operation, preferring the thread-private - // queue if available, and return immediately. Assumes that work_started() - // has not yet been called for the operation. - BOOST_ASIO_DECL void post_private_immediate_completion(operation* op); - - // Request invocation of the given operation, preferring the thread-private - // queue if available, and return immediately. Assumes that work_started() - // was previously called for the operation. - BOOST_ASIO_DECL void post_private_deferred_completion(operation* op); - // Process unfinished operations as part of a shutdown_service operation. // Assumes that work_started() was previously called for the operations. BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops); private: - // Structure containing information about an idle thread. - struct thread_info; - - // Request invocation of the given operation, avoiding the thread-private - // queue, and return immediately. Assumes that work_started() has not yet - // been called for the operation. - BOOST_ASIO_DECL void post_non_private_immediate_completion(operation* op); + // Structure containing thread-specific data. + typedef task_io_service_thread_info thread_info; - // Request invocation of the given operation, avoiding the thread-private - // queue, and return immediately. Assumes that work_started() was previously - // called for the operation. - BOOST_ASIO_DECL void post_non_private_deferred_completion(operation* op); + // Enqueue the given operation following a failed attempt to dispatch the + // operation for immediate invocation. + BOOST_ASIO_DECL void do_dispatch(operation* op); // Run at most one operation. May block. BOOST_ASIO_DECL std::size_t do_run_one(mutex::scoped_lock& lock, thread_info& this_thread, const boost::system::error_code& ec); // Poll for at most one operation. BOOST_ASIO_DECL std::size_t do_poll_one(mutex::scoped_lock& lock, thread_info& this_thread, const boost::system::error_code& ec); // Stop the task and all idle threads. BOOST_ASIO_DECL void stop_all_threads(mutex::scoped_lock& lock); - // Wakes a single idle thread and unlocks the mutex. Returns true if an idle - // thread was found. If there is no idle thread, returns false and leaves the - // mutex locked. - BOOST_ASIO_DECL bool wake_one_idle_thread_and_unlock( - mutex::scoped_lock& lock); - // Wake a single idle thread, or the task, and always unlock the mutex. BOOST_ASIO_DECL void wake_one_thread_and_unlock( mutex::scoped_lock& lock); // Helper class to perform task-related operations on block exit. struct task_cleanup; @@ -172,12 +153,15 @@ private: // Whether to optimise for single-threaded use cases. const bool one_thread_; // Mutex to protect access to internal data. mutable mutex mutex_; + // Event to wake up blocked threads. + event wakeup_event_; + // The task to be run by this service. reactor* task_; // Operation object to represent the position of the task in the queue. struct task_operation : operation { @@ -198,15 +182,12 @@ private: // Flag to indicate that the dispatcher has been shut down. bool shutdown_; // Per-thread call stack to track the state of each thread in the io_service. typedef call_stack<task_io_service, thread_info> thread_call_stack; - - // The threads that are currently idle. - thread_info* first_idle_thread_; }; } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp deleted file mode 100644 index 4aa0ec3..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// -// detail/task_io_service_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP -#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -namespace boost { -namespace asio { -namespace detail { - -class task_io_service; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp index 1bf1301..ea1c85e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp @@ -1,11 +1,11 @@ // // detail/task_io_service_operation.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP @@ -15,20 +15,21 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/system/error_code.hpp> #include <boost/asio/detail/handler_tracking.hpp> #include <boost/asio/detail/op_queue.hpp> -#include <boost/asio/detail/task_io_service_fwd.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { +class task_io_service; + // Base class for all operations. A function pointer is used instead of virtual // functions to avoid the associated overhead. class task_io_service_operation BOOST_ASIO_INHERIT_TRACKED_HANDLER { public: void complete(task_io_service& owner, diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp new file mode 100644 index 0000000..7165552 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp @@ -0,0 +1,42 @@ +// +// detail/task_io_service_thread_info.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP +#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/op_queue.hpp> +#include <boost/asio/detail/thread_info_base.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class task_io_service; +class task_io_service_operation; + +struct task_io_service_thread_info : public thread_info_base +{ + op_queue<task_io_service_operation> private_op_queue; + long private_outstanding_work; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/thread.hpp b/3rdParty/Boost/src/boost/asio/detail/thread.hpp index 5b452cf..68755e4 100644 --- a/3rdParty/Boost/src/boost/asio/detail/thread.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/thread.hpp @@ -1,11 +1,11 @@ // // detail/thread.hpp // ~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_THREAD_HPP @@ -14,40 +14,44 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) # include <boost/asio/detail/null_thread.hpp> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # if defined(UNDER_CE) # include <boost/asio/detail/wince_thread.hpp> # else # include <boost/asio/detail/win_thread.hpp> # endif -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_thread.hpp> +#elif defined(BOOST_ASIO_HAS_STD_THREAD) +# include <boost/asio/detail/std_thread.hpp> #else -# error Only Windows and POSIX are supported! +# error Only Windows, POSIX and std::thread are supported! #endif namespace boost { namespace asio { namespace detail { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) typedef null_thread thread; -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # if defined(UNDER_CE) typedef wince_thread thread; # else typedef win_thread thread; # endif -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_thread thread; +#elif defined(BOOST_ASIO_HAS_STD_THREAD) +typedef std_thread thread; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp b/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp new file mode 100644 index 0000000..9a12e25 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp @@ -0,0 +1,93 @@ +// +// detail/thread_info_base.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_THREAD_INFO_BASE_HPP +#define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <climits> +#include <cstddef> +#include <boost/asio/detail/noncopyable.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class thread_info_base + : private noncopyable +{ +public: + thread_info_base() + : reusable_memory_(0) + { + } + + ~thread_info_base() + { + if (reusable_memory_) + ::operator delete(reusable_memory_); + } + + static void* allocate(thread_info_base* this_thread, std::size_t size) + { + if (this_thread && this_thread->reusable_memory_) + { + void* const pointer = this_thread->reusable_memory_; + this_thread->reusable_memory_ = 0; + + unsigned char* const mem = static_cast<unsigned char*>(pointer); + if (static_cast<std::size_t>(mem[0]) >= size) + { + mem[size] = mem[0]; + return pointer; + } + + ::operator delete(pointer); + } + + void* const pointer = ::operator new(size + 1); + unsigned char* const mem = static_cast<unsigned char*>(pointer); + mem[size] = (size <= UCHAR_MAX) ? static_cast<unsigned char>(size) : 0; + return pointer; + } + + static void deallocate(thread_info_base* this_thread, + void* pointer, std::size_t size) + { + if (size <= UCHAR_MAX) + { + if (this_thread && this_thread->reusable_memory_ == 0) + { + unsigned char* const mem = static_cast<unsigned char*>(pointer); + mem[0] = mem[size]; + this_thread->reusable_memory_ = pointer; + return; + } + } + + ::operator delete(pointer); + } + +private: + void* reusable_memory_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp index bfb545a..3ca8b8a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp @@ -1,11 +1,11 @@ // // detail/throw_error.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_THROW_ERROR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp b/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp new file mode 100644 index 0000000..636e1a2 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp @@ -0,0 +1,53 @@ +// +// detail/throw_exception.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_THROW_EXCEPTION_HPP +#define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) +# include <boost/throw_exception.hpp> +#endif // defined(BOOST_ASIO_BOOST_THROW_EXCEPTION) + +namespace boost { +namespace asio { +namespace detail { + +#if defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) +using boost::throw_exception; +#else // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) + +// Declare the throw_exception function for all targets. +template <typename Exception> +void throw_exception(const Exception& e); + +// Only define the throw_exception function when exceptions are enabled. +// Otherwise, it is up to the application to provide a definition of this +// function. +# if !defined(BOOST_ASIO_NO_EXCEPTIONS) +template <typename Exception> +void throw_exception(const Exception& e) +{ + throw e; +} +# endif // !defined(BOOST_ASIO_NO_EXCEPTIONS) + +#endif // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) + +} // namespace detail +} // namespace asio +} // namespace boost + +#endif // BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp index d14ba7c..1c94bcd 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp @@ -1,11 +1,11 @@ // // detail/timer_queue.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_QUEUE_HPP @@ -15,16 +15,15 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <vector> -#include <boost/config.hpp> -#include <boost/limits.hpp> -#include <boost/cstdint.hpp> +#include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/date_time_fwd.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> @@ -285,13 +284,13 @@ private: // Helper function to convert a duration into milliseconds. template <typename Duration> long to_msec(const Duration& d, long max_duration) const { if (d.ticks() <= 0) return 0; - boost::int64_t msec = d.total_milliseconds(); + int64_t msec = d.total_milliseconds(); if (msec == 0) return 1; if (msec > max_duration) return max_duration; return static_cast<long>(msec); } @@ -299,13 +298,13 @@ private: // Helper function to convert a duration into microseconds. template <typename Duration> long to_usec(const Duration& d, long max_duration) const { if (d.ticks() <= 0) return 0; - boost::int64_t usec = d.total_microseconds(); + int64_t usec = d.total_microseconds(); if (usec == 0) return 1; if (usec > max_duration) return max_duration; return static_cast<long>(usec); } diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp index cc7ef34..44ac90f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp @@ -1,11 +1,11 @@ // // detail/timer_queue_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP @@ -55,12 +55,15 @@ private: friend class timer_queue_set; // Next timer queue in the set. timer_queue_base* next_; }; +template <typename Time_Traits> +class timer_queue; + } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp deleted file mode 100644 index c97753f..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// detail/timer_queue_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_TIMER_QUEUE_FWD_HPP -#define BOOST_ASIO_DETAIL_TIMER_QUEUE_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -namespace boost { -namespace asio { -namespace detail { - -template <typename Time_Traits> -class timer_queue; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp index 4c32ece..9164059 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp @@ -1,11 +1,11 @@ // // detail/timer_queue_ptime.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP @@ -17,12 +17,14 @@ #include <boost/asio/time_traits.hpp> #include <boost/asio/detail/timer_queue.hpp> #include <boost/asio/detail/push_options.hpp> +#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + namespace boost { namespace asio { namespace detail { struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {}; @@ -79,12 +81,14 @@ private: }; } // namespace detail } // namespace asio } // namespace boost +#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) + #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/timer_queue_ptime.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp index 0289259..e008613 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp @@ -1,11 +1,11 @@ // // detail/timer_queue_set.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_QUEUE_SET_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp index 8feea78..8fdc36f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp @@ -1,11 +1,11 @@ // // detail/timer_scheduler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_SCHEDULER_HPP @@ -15,13 +15,15 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/asio/detail/timer_scheduler_fwd.hpp> -#if defined(BOOST_ASIO_HAS_IOCP) +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +# include <boost/asio/detail/winrt_timer_scheduler.hpp> +#elif defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_service.hpp> #elif defined(BOOST_ASIO_HAS_EPOLL) # include <boost/asio/detail/epoll_reactor.hpp> #elif defined(BOOST_ASIO_HAS_KQUEUE) # include <boost/asio/detail/kqueue_reactor.hpp> #elif defined(BOOST_ASIO_HAS_DEV_POLL) diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp index a72e256..5bcf249 100644 --- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp @@ -1,11 +1,11 @@ // // detail/timer_scheduler_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP @@ -14,38 +14,28 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_ASIO_HAS_IOCP) -# include <boost/asio/detail/win_iocp_io_service_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_EPOLL) -# include <boost/asio/detail/epoll_reactor_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_KQUEUE) -# include <boost/asio/detail/kqueue_reactor_fwd.hpp> -#elif defined(BOOST_ASIO_HAS_DEV_POLL) -# include <boost/asio/detail/dev_poll_reactor_fwd.hpp> -#else -# include <boost/asio/detail/select_reactor_fwd.hpp> -#endif - namespace boost { namespace asio { namespace detail { -#if defined(BOOST_ASIO_HAS_IOCP) -typedef win_iocp_io_service timer_scheduler; +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) +typedef class winrt_timer_scheduler timer_scheduler; +#elif defined(BOOST_ASIO_HAS_IOCP) +typedef class win_iocp_io_service timer_scheduler; #elif defined(BOOST_ASIO_HAS_EPOLL) -typedef epoll_reactor timer_scheduler; +typedef class epoll_reactor timer_scheduler; #elif defined(BOOST_ASIO_HAS_KQUEUE) -typedef kqueue_reactor timer_scheduler; +typedef class kqueue_reactor timer_scheduler; #elif defined(BOOST_ASIO_HAS_DEV_POLL) -typedef dev_poll_reactor timer_scheduler; +typedef class dev_poll_reactor timer_scheduler; #else -typedef select_reactor timer_scheduler; +typedef class select_reactor timer_scheduler; #endif } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp index d14a959..4b4e766 100644 --- a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp @@ -1,11 +1,11 @@ // // detail/tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_TSS_PTR_HPP @@ -14,19 +14,19 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) # include <boost/asio/detail/null_tss_ptr.hpp> #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) # include <boost/asio/detail/keyword_tss_ptr.hpp> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_tss_ptr.hpp> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_tss_ptr.hpp> #else # error Only Windows and POSIX are supported! #endif #include <boost/asio/detail/push_options.hpp> @@ -34,32 +34,32 @@ namespace boost { namespace asio { namespace detail { template <typename T> class tss_ptr -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) : public null_tss_ptr<T> #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) : public keyword_tss_ptr<T> -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) : public win_tss_ptr<T> -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) : public posix_tss_ptr<T> #endif { public: void operator=(T* value) { -#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) +#if !defined(BOOST_ASIO_HAS_THREADS) null_tss_ptr<T>::operator=(value); #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) keyword_tss_ptr<T>::operator=(value); -#elif defined(BOOST_WINDOWS) +#elif defined(BOOST_ASIO_WINDOWS) win_tss_ptr<T>::operator=(value); -#elif defined(BOOST_HAS_PTHREADS) +#elif defined(BOOST_ASIO_HAS_PTHREADS) posix_tss_ptr<T>::operator=(value); #endif } }; } // namespace detail diff --git a/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp b/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp new file mode 100644 index 0000000..67e0404 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp @@ -0,0 +1,60 @@ +// +// detail/type_traits.hpp +// ~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_TYPE_TRAITS_HPP +#define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) +# include <type_traits> +#else // defined(BOOST_ASIO_HAS_TYPE_TRAITS) +# include <boost/type_traits/add_const.hpp> +# include <boost/type_traits/is_const.hpp> +# include <boost/type_traits/is_convertible.hpp> +# include <boost/type_traits/is_function.hpp> +# include <boost/type_traits/is_same.hpp> +# include <boost/type_traits/remove_pointer.hpp> +# include <boost/type_traits/remove_reference.hpp> +# include <boost/utility/enable_if.hpp> +#endif // defined(BOOST_ASIO_HAS_TYPE_TRAITS) + +namespace boost { +namespace asio { + +#if defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) +using std::add_const; +using std::enable_if; +using std::is_const; +using std::is_convertible; +using std::is_function; +using std::is_same; +using std::remove_pointer; +using std::remove_reference; +#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) +using boost::add_const; +template <bool Condition, typename Type = void> +struct enable_if : boost::enable_if_c<Condition, Type> {}; +using boost::is_const; +using boost::is_convertible; +using boost::is_function; +using boost::is_same; +using boost::remove_pointer; +using boost::remove_reference; +#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) + +} // namespace asio +} // namespace boost + +#endif // BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp b/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp new file mode 100644 index 0000000..b116fe8 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp @@ -0,0 +1,63 @@ +// +// detail/variadic_templates.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP +#define BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) + +# define BOOST_ASIO_VARIADIC_TPARAMS(n) BOOST_ASIO_VARIADIC_TPARAMS_##n + +# define BOOST_ASIO_VARIADIC_TPARAMS_1 \ + typename T1 +# define BOOST_ASIO_VARIADIC_TPARAMS_2 \ + typename T1, typename T2 +# define BOOST_ASIO_VARIADIC_TPARAMS_3 \ + typename T1, typename T2, typename T3 +# define BOOST_ASIO_VARIADIC_TPARAMS_4 \ + typename T1, typename T2, typename T3, typename T4 +# define BOOST_ASIO_VARIADIC_TPARAMS_5 \ + typename T1, typename T2, typename T3, typename T4, typename T5 + +# define BOOST_ASIO_VARIADIC_TARGS(n) BOOST_ASIO_VARIADIC_TARGS_##n + +# define BOOST_ASIO_VARIADIC_TARGS_1 x1 +# define BOOST_ASIO_VARIADIC_TARGS_2 x1, x2 +# define BOOST_ASIO_VARIADIC_TARGS_3 x1, x2, x3 +# define BOOST_ASIO_VARIADIC_TARGS_4 x1, x2, x3, x4 +# define BOOST_ASIO_VARIADIC_TARGS_5 x1, x2, x3, x4, x5 + +# define BOOST_ASIO_VARIADIC_PARAMS(n) BOOST_ASIO_VARIADIC_PARAMS_##n + +# define BOOST_ASIO_VARIADIC_PARAMS_1 T1 x1 +# define BOOST_ASIO_VARIADIC_PARAMS_2 T1 x1, T2 x2 +# define BOOST_ASIO_VARIADIC_PARAMS_3 T1 x1, T2 x2, T3 x3 +# define BOOST_ASIO_VARIADIC_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4 +# define BOOST_ASIO_VARIADIC_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5 + +# define BOOST_ASIO_VARIADIC_ARGS(n) BOOST_ASIO_VARIADIC_ARGS_##n + +# define BOOST_ASIO_VARIADIC_ARGS_1 x1 +# define BOOST_ASIO_VARIADIC_ARGS_2 x1, x2 +# define BOOST_ASIO_VARIADIC_ARGS_3 x1, x2, x3 +# define BOOST_ASIO_VARIADIC_ARGS_4 x1, x2, x3, x4 +# define BOOST_ASIO_VARIADIC_ARGS_5 x1, x2, x3, x4, x5 + +# define BOOST_ASIO_VARIADIC_GENERATE(m) m(1) m(2) m(3) m(4) m(5) + +#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) + +#endif // BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp index b511be8..6f2cbc5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp @@ -1,11 +1,11 @@ // // detail/wait_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WAIT_HANDLER_HPP @@ -13,12 +13,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/io_service.hpp> @@ -43,25 +44,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/) { // Take ownership of the handler object. wait_handler* h(static_cast<wait_handler*>(base)); - ptr p = { boost::addressof(h->handler_), h, h }; + ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(h->handler_, h->ec_); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp b/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp index 0209eb0..cb6c045 100644 --- a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp @@ -1,11 +1,11 @@ // // detail/wait_op.hpp // ~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WAIT_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp index af9a08d..2604d10 100644 --- a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp @@ -1,11 +1,11 @@ // // detail/weak_ptr.hpp // ~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WEAK_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_event.hpp b/3rdParty/Boost/src/boost/asio/detail/win_event.hpp index 6314048..8ef90c5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_event.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_event.hpp @@ -1,11 +1,11 @@ // // detail/win_event.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_EVENT_HPP @@ -14,15 +14,15 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) -#include <boost/assert.hpp> +#include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -34,65 +34,95 @@ class win_event { public: // Constructor. BOOST_ASIO_DECL win_event(); // Destructor. - ~win_event() + BOOST_ASIO_DECL ~win_event(); + + // Signal the event. (Retained for backward compatibility.) + template <typename Lock> + void signal(Lock& lock) { - ::CloseHandle(event_); + this->signal_all(lock); } - // Signal the event. + // Signal all waiters. template <typename Lock> - void signal(Lock& lock) + void signal_all(Lock& lock) { - BOOST_ASSERT(lock.locked()); + BOOST_ASIO_ASSERT(lock.locked()); (void)lock; - ::SetEvent(event_); + state_ |= 1; + ::SetEvent(events_[0]); } - // Signal the event and unlock the mutex. + // Unlock the mutex and signal one waiter. template <typename Lock> - void signal_and_unlock(Lock& lock) + void unlock_and_signal_one(Lock& lock) { - BOOST_ASSERT(lock.locked()); + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + bool have_waiters = (state_ > 1); lock.unlock(); - ::SetEvent(event_); + if (have_waiters) + ::SetEvent(events_[1]); + } + + // If there's a waiter, unlock the mutex and signal it. + template <typename Lock> + bool maybe_unlock_and_signal_one(Lock& lock) + { + BOOST_ASIO_ASSERT(lock.locked()); + state_ |= 1; + if (state_ > 1) + { + lock.unlock(); + ::SetEvent(events_[1]); + return true; + } + return false; } // Reset the event. template <typename Lock> void clear(Lock& lock) { - BOOST_ASSERT(lock.locked()); + BOOST_ASIO_ASSERT(lock.locked()); (void)lock; - ::ResetEvent(event_); + ::ResetEvent(events_[0]); + state_ &= ~std::size_t(1); } // Wait for the event to become signalled. template <typename Lock> void wait(Lock& lock) { - BOOST_ASSERT(lock.locked()); - lock.unlock(); - ::WaitForSingleObject(event_, INFINITE); - lock.lock(); + BOOST_ASIO_ASSERT(lock.locked()); + while ((state_ & 1) == 0) + { + state_ += 2; + lock.unlock(); + ::WaitForMultipleObjects(2, events_, false, INFINITE); + lock.lock(); + state_ -= 2; + } } private: - HANDLE event_; + HANDLE events_[2]; + std::size_t state_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_event.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_EVENT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp index afb40d0..89f5ffd 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp @@ -1,11 +1,11 @@ // // detail/win_fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP @@ -14,15 +14,16 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #include <boost/asio/detail/noncopyable.hpp> +#include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { @@ -58,32 +59,28 @@ public: bool set(socket_type descriptor) { for (u_int i = 0; i < fd_set_->fd_count; ++i) if (fd_set_->fd_array[i] == descriptor) return true; - if (fd_set_->fd_count == capacity_) - { - u_int new_capacity = capacity_ + capacity_ / 2; - win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new( - sizeof(win_fd_set) - sizeof(SOCKET) - + sizeof(SOCKET) * (new_capacity))); - - new_fd_set->fd_count = fd_set_->fd_count; - for (u_int i = 0; i < fd_set_->fd_count; ++i) - new_fd_set->fd_array[i] = fd_set_->fd_array[i]; - - ::operator delete(fd_set_); - fd_set_ = new_fd_set; - capacity_ = new_capacity; - } - + reserve(fd_set_->fd_count + 1); fd_set_->fd_array[fd_set_->fd_count++] = descriptor; return true; } + void set(reactor_op_queue<socket_type>& operations, op_queue<operation>&) + { + reactor_op_queue<socket_type>::iterator i = operations.begin(); + while (i != operations.end()) + { + reactor_op_queue<socket_type>::iterator op_iter = i++; + reserve(fd_set_->fd_count + 1); + fd_set_->fd_array[fd_set_->fd_count++] = op_iter->first; + } + } + bool is_set(socket_type descriptor) const { return !!__WSAFDIsSet(descriptor, const_cast<fd_set*>(reinterpret_cast<const fd_set*>(fd_set_))); } @@ -94,32 +91,61 @@ public: socket_type max_descriptor() const { return max_descriptor_; } -private: + void perform(reactor_op_queue<socket_type>& operations, + op_queue<operation>& ops) const + { + for (u_int i = 0; i < fd_set_->fd_count; ++i) + operations.perform_operations(fd_set_->fd_array[i], ops); + } +private: // This structure is defined to be compatible with the Windows API fd_set // structure, but without being dependent on the value of FD_SETSIZE. We use // the "struct hack" to allow the number of descriptors to be varied at // runtime. struct win_fd_set { u_int fd_count; SOCKET fd_array[1]; }; + // Increase the fd_set_ capacity to at least the specified number of elements. + void reserve(u_int n) + { + if (n <= capacity_) + return; + + u_int new_capacity = capacity_ + capacity_ / 2; + if (new_capacity < n) + new_capacity = n; + + win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new( + sizeof(win_fd_set) - sizeof(SOCKET) + + sizeof(SOCKET) * (new_capacity))); + + new_fd_set->fd_count = fd_set_->fd_count; + for (u_int i = 0; i < fd_set_->fd_count; ++i) + new_fd_set->fd_array[i] = fd_set_->fd_array[i]; + + ::operator delete(fd_set_); + fd_set_ = new_fd_set; + capacity_ = new_capacity; + } + win_fd_set* fd_set_; u_int capacity_; socket_type max_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp index 5e56aa3..ebe580d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp @@ -1,11 +1,11 @@ // // detail/win_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -42,13 +42,14 @@ public: // Constructor for a full fenced block. explicit win_fenced_block(full_t) { #if defined(__BORLANDC__) LONG barrier = 0; ::InterlockedExchange(&barrier, 1); -#elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier)) +#elif defined(BOOST_ASIO_MSVC) \ + && ((BOOST_ASIO_MSVC < 1400) || !defined(MemoryBarrier)) # if defined(_M_IX86) # pragma warning(push) # pragma warning(disable:4793) LONG barrier; __asm { xchg barrier, eax } # pragma warning(pop) @@ -61,13 +62,14 @@ public: // Destructor. ~win_fenced_block() { #if defined(__BORLANDC__) LONG barrier = 0; ::InterlockedExchange(&barrier, 1); -#elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier)) +#elif defined(BOOST_ASIO_MSVC) \ + && ((BOOST_ASIO_MSVC < 1400) || !defined(MemoryBarrier)) # if defined(_M_IX86) # pragma warning(push) # pragma warning(disable:4793) LONG barrier; __asm { xchg barrier, eax } # pragma warning(pop) @@ -81,9 +83,9 @@ public: } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp index 8b41ab4..a69a291 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_handle_read_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -18,13 +18,13 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/error.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -54,13 +54,13 @@ public: std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (owner) { @@ -79,13 +79,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp index 68a9f90..c769884 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_handle_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -17,16 +17,17 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/cstdint.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> +#include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/win_iocp_handle_read_op.hpp> #include <boost/asio/detail/win_iocp_handle_write_op.hpp> #include <boost/asio/detail/win_iocp_io_service.hpp> @@ -126,13 +127,13 @@ public: return write_some_at(impl, 0, buffers, ec); } // Write the given data at the specified offset. Returns the number of bytes // written. template <typename ConstBufferSequence> - size_t write_some_at(implementation_type& impl, boost::uint64_t offset, + size_t write_some_at(implementation_type& impl, uint64_t offset, const ConstBufferSequence& buffers, boost::system::error_code& ec) { boost::asio::const_buffer buffer = buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers); @@ -140,17 +141,17 @@ public: } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_write_some(implementation_type& impl, - const ConstBufferSequence& buffers, Handler handler) + const ConstBufferSequence& buffers, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some")); @@ -160,18 +161,18 @@ public: p.v = p.p = 0; } // Start an asynchronous write at a specified offset. The data being written // must be valid for the lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> - void async_write_some_at(implementation_type& impl, boost::uint64_t offset, - const ConstBufferSequence& buffers, Handler handler) + void async_write_some_at(implementation_type& impl, uint64_t offset, + const ConstBufferSequence& buffers, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some_at")); @@ -188,13 +189,13 @@ public: { return read_some_at(impl, 0, buffers, ec); } // Read some data at a specified offset. Returns the number of bytes received. template <typename MutableBufferSequence> - size_t read_some_at(implementation_type& impl, boost::uint64_t offset, + size_t read_some_at(implementation_type& impl, uint64_t offset, const MutableBufferSequence& buffers, boost::system::error_code& ec) { boost::asio::mutable_buffer buffer = buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers); @@ -202,17 +203,17 @@ public: } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_read_some(implementation_type& impl, - const MutableBufferSequence& buffers, Handler handler) + const MutableBufferSequence& buffers, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some")); @@ -223,18 +224,18 @@ public: } // Start an asynchronous read at a specified offset. The buffer for the data // being received must be valid for the lifetime of the asynchronous // operation. template <typename MutableBufferSequence, typename Handler> - void async_read_some_at(implementation_type& impl, boost::uint64_t offset, - const MutableBufferSequence& buffers, Handler handler) + void async_read_some_at(implementation_type& impl, uint64_t offset, + const MutableBufferSequence& buffers, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some_at")); @@ -245,52 +246,52 @@ public: } private: // Prevent the use of the null_buffers type with this service. size_t write_some(implementation_type& impl, const null_buffers& buffers, boost::system::error_code& ec); - size_t write_some_at(implementation_type& impl, boost::uint64_t offset, + size_t write_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, boost::system::error_code& ec); template <typename Handler> void async_write_some(implementation_type& impl, - const null_buffers& buffers, Handler handler); + const null_buffers& buffers, Handler& handler); template <typename Handler> - void async_write_some_at(implementation_type& impl, boost::uint64_t offset, - const null_buffers& buffers, Handler handler); + void async_write_some_at(implementation_type& impl, uint64_t offset, + const null_buffers& buffers, Handler& handler); size_t read_some(implementation_type& impl, const null_buffers& buffers, boost::system::error_code& ec); - size_t read_some_at(implementation_type& impl, boost::uint64_t offset, + size_t read_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, boost::system::error_code& ec); template <typename Handler> void async_read_some(implementation_type& impl, - const null_buffers& buffers, Handler handler); + const null_buffers& buffers, Handler& handler); template <typename Handler> - void async_read_some_at(implementation_type& impl, boost::uint64_t offset, - const null_buffers& buffers, Handler handler); + void async_read_some_at(implementation_type& impl, uint64_t offset, + const null_buffers& buffers, Handler& handler); // Helper class for waiting for synchronous operations to complete. class overlapped_wrapper; // Helper function to perform a synchronous write operation. BOOST_ASIO_DECL size_t do_write(implementation_type& impl, - boost::uint64_t offset, const boost::asio::const_buffer& buffer, + uint64_t offset, const boost::asio::const_buffer& buffer, boost::system::error_code& ec); // Helper function to start a write operation. BOOST_ASIO_DECL void start_write_op(implementation_type& impl, - boost::uint64_t offset, const boost::asio::const_buffer& buffer, + uint64_t offset, const boost::asio::const_buffer& buffer, operation* op); // Helper function to perform a synchronous write operation. BOOST_ASIO_DECL size_t do_read(implementation_type& impl, - boost::uint64_t offset, const boost::asio::mutable_buffer& buffer, + uint64_t offset, const boost::asio::mutable_buffer& buffer, boost::system::error_code& ec); // Helper function to start a read operation. BOOST_ASIO_DECL void start_read_op(implementation_type& impl, - boost::uint64_t offset, const boost::asio::mutable_buffer& buffer, + uint64_t offset, const boost::asio::mutable_buffer& buffer, operation* op); // Update the ID of the thread from which cancellation is safe. BOOST_ASIO_DECL void update_cancellation_thread_id(implementation_type& impl); // Helper function to close a handle when the associated object is being diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp index c87cd60..48af0b7 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_handle_write_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -18,13 +18,13 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/error.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -50,13 +50,13 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred) { // Take ownership of the operation object. win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (owner) { @@ -71,13 +71,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp index 0e3bb0b..215b796 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_io_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP @@ -16,26 +16,25 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/limits.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/detail/call_stack.hpp> +#include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/thread.hpp> #include <boost/asio/detail/timer_queue_base.hpp> -#include <boost/asio/detail/timer_queue_fwd.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> -#include <boost/asio/detail/win_iocp_io_service_fwd.hpp> #include <boost/asio/detail/win_iocp_operation.hpp> +#include <boost/asio/detail/win_iocp_thread_info.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -104,26 +103,26 @@ public: stop(); } // Return whether a handler can be dispatched immediately. bool can_dispatch() { - return call_stack<win_iocp_io_service>::contains(this) != 0; + return thread_call_stack::contains(this) != 0; } // Request invocation of the given handler. template <typename Handler> - void dispatch(Handler handler); + void dispatch(Handler& handler); // Request invocation of the given handler and return immediately. template <typename Handler> - void post(Handler handler); + void post(Handler& handler); // Request invocation of the given operation and return immediately. Assumes // that work_started() has not yet been called for the operation. - void post_immediate_completion(win_iocp_operation* op) + void post_immediate_completion(win_iocp_operation* op, bool) { work_started(); post_deferred_completion(op); } // Request invocation of the given operation and return immediately. Assumes @@ -137,13 +136,13 @@ public: // Request invocation of the given operation using the thread-private queue // and return immediately. Assumes that work_started() has not yet been // called for the operation. void post_private_immediate_completion(win_iocp_operation* op) { - post_immediate_completion(op); + post_immediate_completion(op, false); } // Request invocation of the given operation using the thread-private queue // and return immediately. Assumes that work_started() was previously called // for the operation. void post_private_deferred_completion(win_iocp_operation* op) @@ -205,12 +204,15 @@ private: // Dequeues at most one operation from the I/O completion port, and then // executes it. Returns the number of operations that were dequeued (i.e. // either 0 or 1). BOOST_ASIO_DECL size_t do_one(bool block, boost::system::error_code& ec); + // Helper to calculate the GetQueuedCompletionStatus timeout. + BOOST_ASIO_DECL static DWORD get_gqcs_timeout(); + // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); @@ -234,22 +236,27 @@ private: // The count of unfinished work. long outstanding_work_; // Flag to indicate whether the event loop has been stopped. mutable long stopped_; + // Flag to indicate whether there is an in-flight stop event. Every event + // posted using PostQueuedCompletionStatus consumes non-paged pool, so to + // avoid exhausting this resouce we limit the number of outstanding events. + long stop_event_posted_; + // Flag to indicate whether the service has been shut down. long shutdown_; enum { - // Timeout to use with GetQueuedCompletionStatus. Some versions of windows - // have a "bug" where a call to GetQueuedCompletionStatus can appear stuck - // even though there are events waiting on the queue. Using a timeout helps - // to work around the issue. - gqcs_timeout = 500, + // Timeout to use with GetQueuedCompletionStatus on older versions of + // Windows. Some versions of windows have a "bug" where a call to + // GetQueuedCompletionStatus can appear stuck even though there are events + // waiting on the queue. Using a timeout helps to work around the issue. + default_gqcs_timeout = 500, // Maximum waitable timer timeout, in milliseconds. max_timeout_msec = 5 * 60 * 1000, // Maximum waitable timer timeout, in microseconds. max_timeout_usec = max_timeout_msec * 1000, @@ -261,12 +268,15 @@ private: // Completion key value to indicate that an operation has posted with the // original last_error and bytes_transferred values stored in the fields of // the OVERLAPPED structure. overlapped_contains_result = 2 }; + // Timeout to use with GetQueuedCompletionStatus. + const DWORD gqcs_timeout_; + // Function object for processing timeouts in a background thread. struct timer_thread_function; friend struct timer_thread_function; // Background thread used for processing timeouts. scoped_ptr<thread> timer_thread_; @@ -282,12 +292,16 @@ private: // The timer queues. timer_queue_set timer_queues_; // The operations that are ready to dispatch. op_queue<win_iocp_operation> completed_ops_; + + // Per-thread call stack to track the state of each thread in the io_service. + typedef call_stack<win_iocp_io_service, + win_iocp_thread_info> thread_call_stack; }; } // namespace detail } // namespace asio } // namespace boost diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp deleted file mode 100644 index ec31fa1..0000000 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// detail/win_iocp_io_service_fwd.hpp -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) -// -// 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_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP -#define BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -#include <boost/asio/detail/config.hpp> - -#if defined(BOOST_ASIO_HAS_IOCP) - -namespace boost { -namespace asio { -namespace detail { - -class win_iocp_io_service; -class win_iocp_overlapped_ptr; - -} // namespace detail -} // namespace asio -} // namespace boost - -#endif // defined(BOOST_ASIO_HAS_IOCP) - -#endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp index 021dfdb..ae49f3f 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_null_buffers_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/reactor_op.hpp> @@ -60,13 +60,13 @@ public: std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // The reactor may have stored a result in the operation object. if (o->ec_) ec = o->ec_; @@ -89,13 +89,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp index 67b5466..41a58c6 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_operation.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP @@ -19,21 +19,22 @@ #if defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/handler_tracking.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> -#include <boost/asio/detail/win_iocp_io_service_fwd.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { +class win_iocp_io_service; + // Base class for all operations. A function pointer is used instead of virtual // functions to avoid the associated overhead. class win_iocp_operation : public OVERLAPPED BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER { diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp index 235f48e..9a48433 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_overlapped_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP @@ -17,13 +17,13 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/error.hpp> -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -47,25 +47,25 @@ public: static void do_complete(io_service_impl* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred) { // Take ownership of the operation object. win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp index a6df254..d461e0d 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_overlapped_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP @@ -16,14 +16,14 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> #include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/win_iocp_overlapped_op.hpp> #include <boost/asio/detail/win_iocp_io_service.hpp> #include <boost/asio/detail/push_options.hpp> @@ -75,13 +75,13 @@ public: // Reset to contain the specified handler, freeing any current OVERLAPPED // object. template <typename Handler> void reset(boost::asio::io_service& io_service, Handler handler) { typedef win_iocp_overlapped_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", &io_service.impl_, "overlapped")); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp index 7d96f6d..a8191ee 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_serial_port_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com) // // 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) // @@ -150,13 +150,13 @@ public: } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_write_some(implementation_type& impl, - const ConstBufferSequence& buffers, Handler handler) + const ConstBufferSequence& buffers, Handler& handler) { handle_service_.async_write_some(impl, buffers, handler); } // Read some data. Returns the number of bytes received. template <typename MutableBufferSequence> @@ -167,13 +167,13 @@ public: } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_read_some(implementation_type& impl, - const MutableBufferSequence& buffers, Handler handler) + const MutableBufferSequence& buffers, Handler& handler) { handle_service_.async_read_some(impl, buffers, handler); } private: // Function pointer type for storing a serial port option. diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp index 18db3b4..86684d5 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_accept_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -77,13 +77,13 @@ public: std::size_t /*bytes_transferred*/) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner) { typename Protocol::endpoint peer_endpoint; std::size_t addr_len = peer_endpoint.capacity(); socket_ops::complete_iocp_accept(o->socket_, @@ -128,13 +128,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, ec); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp new file mode 100644 index 0000000..f940e0a --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp @@ -0,0 +1,126 @@ +// +// detail/win_iocp_socket_connect_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP +#define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_HAS_IOCP) + +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/fenced_block.hpp> +#include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/reactor_op.hpp> +#include <boost/asio/detail/socket_ops.hpp> +#include <boost/asio/error.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class win_iocp_socket_connect_op_base : public reactor_op +{ +public: + win_iocp_socket_connect_op_base(socket_type socket, func_type complete_func) + : reactor_op(&win_iocp_socket_connect_op_base::do_perform, complete_func), + socket_(socket), + connect_ex_(false) + { + } + + static bool do_perform(reactor_op* base) + { + win_iocp_socket_connect_op_base* o( + static_cast<win_iocp_socket_connect_op_base*>(base)); + + return socket_ops::non_blocking_connect(o->socket_, o->ec_); + } + + socket_type socket_; + bool connect_ex_; +}; + +template <typename Handler> +class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base +{ +public: + BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_connect_op); + + win_iocp_socket_connect_op(socket_type socket, Handler& handler) + : win_iocp_socket_connect_op_base(socket, + &win_iocp_socket_connect_op::do_complete), + handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) + { + } + + static void do_complete(io_service_impl* owner, operation* base, + const boost::system::error_code& result_ec, + std::size_t /*bytes_transferred*/) + { + boost::system::error_code ec(result_ec); + + // Take ownership of the operation object. + win_iocp_socket_connect_op* o( + static_cast<win_iocp_socket_connect_op*>(base)); + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; + + if (owner) + { + if (o->connect_ex_) + socket_ops::complete_iocp_connect(o->socket_, ec); + else + ec = o->ec_; + } + + BOOST_ASIO_HANDLER_COMPLETION((o)); + + // Make a copy of the handler so that the memory can be deallocated before + // the upcall is made. Even if we're not about to make an upcall, a + // sub-object of the handler may be the true owner of the memory associated + // with the handler. Consequently, a local copy of the handler is required + // to ensure that any owning sub-object remains valid until after we have + // deallocated the memory here. + detail::binder1<Handler, boost::system::error_code> + handler(o->handler_, ec); + p.h = boost::asio::detail::addressof(handler.handler_); + p.reset(); + + // Make the upcall if required. + if (owner) + { + fenced_block b(fenced_block::half); + BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); + boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); + BOOST_ASIO_HANDLER_INVOCATION_END; + } + } + +private: + Handler handler_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_HAS_IOCP) + +#endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp index b50b742..f7fdcee 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_recv_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -57,13 +57,13 @@ public: std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) @@ -83,13 +83,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp index 798921d..5e1ade6 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_recvfrom_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -64,13 +64,13 @@ public: { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recvfrom_op* o( static_cast<win_iocp_socket_recvfrom_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) @@ -90,13 +90,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp index db13fb8..a09feab 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_recvmsg_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -60,13 +60,13 @@ public: { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recvmsg_op* o( static_cast<win_iocp_socket_recvmsg_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) @@ -84,13 +84,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp index fbd00ca..ef25b88 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_send_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP @@ -16,13 +16,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/operation.hpp> @@ -55,13 +55,13 @@ public: std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op*>(base)); - ptr p = { boost::addressof(o->handler_), o, o }; + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) @@ -78,13 +78,13 @@ public: // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); - p.h = boost::addressof(handler.handler_); + p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp index d6dc98b..d82e40e 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP @@ -17,32 +17,32 @@ #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) #include <cstring> -#include <boost/utility/addressof.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/operation.hpp> -#include <boost/asio/detail/reactive_socket_connect_op.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/win_iocp_io_service.hpp> #include <boost/asio/detail/win_iocp_null_buffers_op.hpp> #include <boost/asio/detail/win_iocp_socket_accept_op.hpp> +#include <boost/asio/detail/win_iocp_socket_connect_op.hpp> #include <boost/asio/detail/win_iocp_socket_recvfrom_op.hpp> #include <boost/asio/detail/win_iocp_socket_send_op.hpp> #include <boost/asio/detail/win_iocp_socket_service_base.hpp> #include <boost/asio/detail/push_options.hpp> @@ -163,12 +163,30 @@ public: other_impl.have_remote_endpoint_ = false; impl.remote_endpoint_ = other_impl.remote_endpoint_; other_impl.remote_endpoint_ = endpoint_type(); } + // Move-construct a new socket implementation from another protocol type. + template <typename Protocol1> + void converting_move_construct(implementation_type& impl, + typename win_iocp_socket_service< + Protocol1>::implementation_type& other_impl) + { + this->base_move_construct(impl, other_impl); + + impl.protocol_ = protocol_type(other_impl.protocol_); + other_impl.protocol_ = typename Protocol1::endpoint().protocol(); + + impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_; + other_impl.have_remote_endpoint_ = false; + + impl.remote_endpoint_ = other_impl.remote_endpoint_; + other_impl.remote_endpoint_ = typename Protocol1::endpoint(); + } + // Open a new socket implementation. boost::system::error_code open(implementation_type& impl, const protocol_type& protocol, boost::system::error_code& ec) { if (!do_open(impl, protocol.family(), protocol.type(), protocol.protocol(), ec)) @@ -288,17 +306,17 @@ public: // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to")); @@ -311,17 +329,17 @@ public: p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler> void async_send_to(implementation_type& impl, const null_buffers&, - const endpoint_type&, socket_base::message_flags, Handler handler) + const endpoint_type&, socket_base::message_flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to(null_buffers)")); @@ -369,18 +387,18 @@ public: // Start an asynchronous receive. The buffer for the data being received and // the sender_endpoint object must both be valid for the lifetime of the // asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endp, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recvfrom_op< MutableBufferSequence, endpoint_type, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(sender_endp, impl.cancel_token_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from")); @@ -393,17 +411,17 @@ public: } // Wait until data can be received without blocking. template <typename Handler> void async_receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from(null_buffers)")); @@ -430,13 +448,13 @@ public: std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0; socket_holder new_socket(socket_ops::sync_accept(impl.socket_, impl.state_, peer_endpoint ? peer_endpoint->data() : 0, peer_endpoint ? &addr_len : 0, ec)); // On success, assign new connection to peer socket object. - if (new_socket.get() >= 0) + if (new_socket.get() != invalid_socket) { if (peer_endpoint) peer_endpoint->resize(addr_len); if (!peer.assign(impl.protocol_, new_socket.get(), ec)) new_socket.release(); } @@ -445,17 +463,17 @@ public: } // Start an asynchronous accept. The peer and peer_endpoint objects // must be valid until the accept's handler is invoked. template <typename Socket, typename Handler> void async_accept(implementation_type& impl, Socket& peer, - endpoint_type* peer_endpoint, Handler handler) + endpoint_type* peer_endpoint, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_accept_op<Socket, protocol_type, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; bool enable_connection_aborted = (impl.state_ & socket_ops::enable_connection_aborted) != 0; p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_, peer_endpoint, enable_connection_aborted, handler); @@ -478,25 +496,25 @@ public: return ec; } // Start an asynchronous connect. template <typename Handler> void async_connect(implementation_type& impl, - const endpoint_type& peer_endpoint, Handler handler) + const endpoint_type& peer_endpoint, Handler& handler) { // Allocate and construct an operation to wrap the handler. - typedef reactive_socket_connect_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typedef win_iocp_socket_connect_op<Handler> op; + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.socket_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect")); - start_connect_op(impl, p.p, peer_endpoint.data(), - static_cast<int>(peer_endpoint.size())); + start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(), + peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p); p.v = p.p = 0; } }; } // namespace detail } // namespace asio diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp index 79580de..f5f0223 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp @@ -1,11 +1,11 @@ // // detail/win_iocp_socket_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP @@ -16,17 +16,16 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_IOCP) -#include <boost/type_traits/is_same.hpp> -#include <boost/utility/addressof.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/mutex.hpp> @@ -35,12 +34,13 @@ #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/win_iocp_io_service.hpp> #include <boost/asio/detail/win_iocp_null_buffers_op.hpp> +#include <boost/asio/detail/win_iocp_socket_connect_op.hpp> #include <boost/asio/detail/win_iocp_socket_send_op.hpp> #include <boost/asio/detail/win_iocp_socket_recv_op.hpp> #include <boost/asio/detail/win_iocp_socket_recvmsg_op.hpp> #include <boost/asio/detail/push_options.hpp> @@ -213,17 +213,17 @@ public: // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler> void async_send(base_implementation_type& impl, const ConstBufferSequence& buffers, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send")); @@ -236,17 +236,17 @@ public: p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler> void async_send(base_implementation_type& impl, const null_buffers&, - socket_base::message_flags, Handler handler) + socket_base::message_flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send(null_buffers)")); @@ -280,17 +280,17 @@ public: // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive(base_implementation_type& impl, const MutableBufferSequence& buffers, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recv_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.state_, impl.cancel_token_, buffers, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive")); @@ -303,17 +303,17 @@ public: p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler> void async_receive(base_implementation_type& impl, const null_buffers&, - socket_base::message_flags flags, Handler handler) + socket_base::message_flags flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive(null_buffers)")); @@ -354,17 +354,17 @@ public: // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler> void async_receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, - socket_base::message_flags& out_flags, Handler handler) + socket_base::message_flags& out_flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recvmsg_op<MutableBufferSequence, Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, out_flags, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_with_flags")); @@ -377,17 +377,17 @@ public: } // Wait until data can be received without blocking. template <typename Handler> void async_receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags in_flags, - socket_base::message_flags& out_flags, Handler handler) + socket_base::message_flags& out_flags, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler); BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_with_flags(null_buffers)")); @@ -443,19 +443,20 @@ protected: // Helper function to start an asynchronous accept operation. BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl, bool peer_is_open, socket_holder& new_socket, int family, int type, int protocol, void* output_buffer, DWORD address_length, operation* op); - // Start an asynchronous read or write operation using the the reactor. + // Start an asynchronous read or write operation using the reactor. BOOST_ASIO_DECL void start_reactor_op(base_implementation_type& impl, int op_type, reactor_op* op); // Start the asynchronous connect operation using the reactor. BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl, - reactor_op* op, const socket_addr_type* addr, std::size_t addrlen); + int family, int type, const socket_addr_type* remote_addr, + std::size_t remote_addrlen, win_iocp_socket_connect_op_base* op); // Helper function to close a socket when the associated object is being // destroyed. BOOST_ASIO_DECL void close_for_destruction(base_implementation_type& impl); // Update the ID of the thread from which cancellation is safe. @@ -464,12 +465,22 @@ protected: // Helper function to get the reactor. If no reactor has been created yet, a // new one is obtained from the io_service and a pointer to it is cached in // this service. BOOST_ASIO_DECL reactor& get_reactor(); + // The type of a ConnectEx function pointer, as old SDKs may not provide it. + typedef BOOL (PASCAL *connect_ex_fn)(SOCKET, + const socket_addr_type*, int, void*, DWORD, DWORD*, OVERLAPPED*); + + // Helper function to get the ConnectEx pointer. If no ConnectEx pointer has + // been obtained yet, one is obtained using WSAIoctl and the pointer is + // cached. Returns a null pointer if ConnectEx is not available. + BOOST_ASIO_DECL connect_ex_fn get_connect_ex( + base_implementation_type& impl, int type); + // Helper function to emulate InterlockedCompareExchangePointer functionality // for: // - very old Platform SDKs; and // - platform SDKs where MSVC's /Wp64 option causes spurious warnings. BOOST_ASIO_DECL void* interlocked_compare_exchange_pointer( void** dest, void* exch, void* cmp); @@ -487,12 +498,15 @@ protected: win_iocp_io_service& iocp_service_; // The reactor used for performing connect operations. This object is created // only if needed. reactor* reactor_; + // Pointer to ConnectEx implementation. + void* connect_ex_; + // Mutex to protect access to the linked list of implementations. boost::asio::detail::mutex mutex_; // The head of a linked list of all implementations. base_implementation_type* impl_list_; }; diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp new file mode 100644 index 0000000..c036d39 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp @@ -0,0 +1,36 @@ +// +// detail/win_iocp_thread_info.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP +#define BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/thread_info_base.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +struct win_iocp_thread_info : public thread_info_base +{ +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp index 930d01f..2f927b3 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp @@ -1,11 +1,11 @@ // // detail/win_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> @@ -72,9 +72,9 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp index 52a972d..a9169ca 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp @@ -1,11 +1,11 @@ // // detail/win_object_handle_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2011 Boris Schaeling (boris@highscore.de) // // 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) // @@ -17,13 +17,13 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) -#include <boost/utility/addressof.hpp> +#include <boost/asio/detail/addressof.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/wait_handler.hpp> #include <boost/asio/error.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/detail/push_options.hpp> @@ -127,17 +127,17 @@ public: // Perform a synchronous wait for the object to enter a signalled state. BOOST_ASIO_DECL void wait(implementation_type& impl, boost::system::error_code& ec); /// Start an asynchronous wait. template <typename Handler> - void async_wait(implementation_type& impl, Handler handler) + void async_wait(implementation_type& impl, Handler& handler) { // Allocate and construct an operation to wrap the handler. typedef wait_handler<Handler> op; - typename op::ptr p = { boost::addressof(handler), + typename op::ptr p = { boost::asio::detail::addressof(handler), boost_asio_handler_alloc_helpers::allocate( sizeof(op), handler), 0 }; p.p = new (p.v) op(handler); BOOST_ASIO_HANDLER_CREATION((p.p, "object_handle", &impl, "async_wait")); diff --git a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp index a54b36b..a6a7e11 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp @@ -1,11 +1,11 @@ // // detail/win_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -68,9 +68,9 @@ struct win_static_mutex #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_static_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp index 754786e..889eca6 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp @@ -1,11 +1,11 @@ // // detail/win_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_THREAD_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> @@ -133,9 +133,9 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_thread.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE) +#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WIN_THREAD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp index 44cacc6..ca32fea 100644 --- a/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp @@ -1,11 +1,11 @@ // // detail/win_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WIN_TSS_PTR_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) +#if defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> @@ -73,9 +73,9 @@ private: #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_tss_ptr.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) +#endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp index 389cb9d..6b9104a 100644 --- a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp @@ -1,11 +1,11 @@ // // detail/wince_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WINCE_THREAD_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) && defined(UNDER_CE) +#if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE) #include <memory> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> @@ -110,9 +110,9 @@ inline DWORD WINAPI wince_thread_function(LPVOID arg) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> -#endif // defined(BOOST_WINDOWS) && defined(UNDER_CE) +#endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WINCE_THREAD_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp new file mode 100644 index 0000000..1c389a0 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp @@ -0,0 +1,296 @@ +// +// detail/winrt_async_manager.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP +#define BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <future> +#include <boost/asio/detail/atomic_count.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/error.hpp> +#include <boost/asio/io_service.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class winrt_async_manager + : public boost::asio::detail::service_base<winrt_async_manager> +{ +public: + // Constructor. + winrt_async_manager(boost::asio::io_service& io_service) + : boost::asio::detail::service_base<winrt_async_manager>(io_service), + io_service_(use_service<io_service_impl>(io_service)), + outstanding_ops_(1) + { + } + + // Destructor. + ~winrt_async_manager() + { + } + + // Destroy all user-defined handler objects owned by the service. + void shutdown_service() + { + if (--outstanding_ops_ > 0) + { + // Block until last operation is complete. + std::future<void> f = promise_.get_future(); + f.wait(); + } + } + + void sync(Windows::Foundation::IAsyncAction^ action, + boost::system::error_code& ec) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto promise = std::make_shared<std::promise<boost::system::error_code>>(); + auto future = promise->get_future(); + + action->Completed = ref new AsyncActionCompletedHandler( + [promise](IAsyncAction^ action, AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + promise->set_value(boost::asio::error::operation_aborted); + break; + case AsyncStatus::Error: + case AsyncStatus::Completed: + default: + boost::system::error_code ec( + action->ErrorCode.Value, + boost::system::system_category()); + promise->set_value(ec); + break; + } + }); + + ec = future.get(); + } + + template <typename TResult> + TResult sync(Windows::Foundation::IAsyncOperation<TResult>^ operation, + boost::system::error_code& ec) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto promise = std::make_shared<std::promise<boost::system::error_code>>(); + auto future = promise->get_future(); + + operation->Completed = ref new AsyncOperationCompletedHandler<TResult>( + [promise](IAsyncOperation<TResult>^ operation, AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + promise->set_value(boost::asio::error::operation_aborted); + break; + case AsyncStatus::Error: + case AsyncStatus::Completed: + default: + boost::system::error_code ec( + operation->ErrorCode.Value, + boost::system::system_category()); + promise->set_value(ec); + break; + } + }); + + ec = future.get(); + return operation->GetResults(); + } + + template <typename TResult, typename TProgress> + TResult sync( + Windows::Foundation::IAsyncOperationWithProgress< + TResult, TProgress>^ operation, + boost::system::error_code& ec) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto promise = std::make_shared<std::promise<boost::system::error_code>>(); + auto future = promise->get_future(); + + operation->Completed + = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>( + [promise](IAsyncOperationWithProgress<TResult, TProgress>^ operation, + AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + promise->set_value(boost::asio::error::operation_aborted); + break; + case AsyncStatus::Started: + break; + case AsyncStatus::Error: + case AsyncStatus::Completed: + default: + boost::system::error_code ec( + operation->ErrorCode.Value, + boost::system::system_category()); + promise->set_value(ec); + break; + } + }); + + ec = future.get(); + return operation->GetResults(); + } + + void async(Windows::Foundation::IAsyncAction^ action, + winrt_async_op<void>* handler) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto on_completed = ref new AsyncActionCompletedHandler( + [this, handler](IAsyncAction^ action, AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + handler->ec_ = boost::asio::error::operation_aborted; + break; + case AsyncStatus::Started: + return; + case AsyncStatus::Completed: + case AsyncStatus::Error: + default: + handler->ec_ = boost::system::error_code( + action->ErrorCode.Value, + boost::system::system_category()); + break; + } + io_service_.post_deferred_completion(handler); + if (--outstanding_ops_ == 0) + promise_.set_value(); + }); + + io_service_.work_started(); + ++outstanding_ops_; + action->Completed = on_completed; + } + + template <typename TResult> + void async(Windows::Foundation::IAsyncOperation<TResult>^ operation, + winrt_async_op<TResult>* handler) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto on_completed = ref new AsyncOperationCompletedHandler<TResult>( + [this, handler](IAsyncOperation<TResult>^ operation, AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + handler->ec_ = boost::asio::error::operation_aborted; + break; + case AsyncStatus::Started: + return; + case AsyncStatus::Completed: + handler->result_ = operation->GetResults(); + // Fall through. + case AsyncStatus::Error: + default: + handler->ec_ = boost::system::error_code( + operation->ErrorCode.Value, + boost::system::system_category()); + break; + } + io_service_.post_deferred_completion(handler); + if (--outstanding_ops_ == 0) + promise_.set_value(); + }); + + io_service_.work_started(); + ++outstanding_ops_; + operation->Completed = on_completed; + } + + template <typename TResult, typename TProgress> + void async( + Windows::Foundation::IAsyncOperationWithProgress< + TResult, TProgress>^ operation, + winrt_async_op<TResult>* handler) + { + using namespace Windows::Foundation; + using Windows::Foundation::AsyncStatus; + + auto on_completed + = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>( + [this, handler](IAsyncOperationWithProgress< + TResult, TProgress>^ operation, AsyncStatus status) + { + switch (status) + { + case AsyncStatus::Canceled: + handler->ec_ = boost::asio::error::operation_aborted; + break; + case AsyncStatus::Started: + return; + case AsyncStatus::Completed: + handler->result_ = operation->GetResults(); + // Fall through. + case AsyncStatus::Error: + default: + handler->ec_ = boost::system::error_code( + operation->ErrorCode.Value, + boost::system::system_category()); + break; + } + io_service_.post_deferred_completion(handler); + if (--outstanding_ops_ == 0) + promise_.set_value(); + }); + + io_service_.work_started(); + ++outstanding_ops_; + operation->Completed = on_completed; + } + +private: + // The io_service implementation used to post completed handlers. + io_service_impl& io_service_; + + // Count of outstanding operations. + atomic_count outstanding_ops_; + + // Used to keep wait for outstanding operations to complete. + std::promise<void> promise_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp new file mode 100644 index 0000000..cded131 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp @@ -0,0 +1,67 @@ +// +// detail/winrt_async_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_ASYNC_OP_HPP +#define BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> +#include <boost/asio/detail/operation.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename TResult> +class winrt_async_op + : public operation +{ +public: + // The error code to be passed to the completion handler. + boost::system::error_code ec_; + + // The result of the operation, to be passed to the completion handler. + TResult result_; + +protected: + winrt_async_op(func_type complete_func) + : operation(complete_func), + result_() + { + } +}; + +template <> +class winrt_async_op<void> + : public operation +{ +public: + // The error code to be passed to the completion handler. + boost::system::error_code ec_; + +protected: + winrt_async_op(func_type complete_func) + : operation(complete_func) + { + } +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp new file mode 100644 index 0000000..fa12889 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp @@ -0,0 +1,119 @@ +// +// detail/winrt_resolve_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP +#define BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/fenced_block.hpp> +#include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/ip/basic_resolver_iterator.hpp> +#include <boost/asio/error.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Protocol, typename Handler> +class winrt_resolve_op : + public winrt_async_op< + Windows::Foundation::Collections::IVectorView< + Windows::Networking::EndpointPair^>^> +{ +public: + BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_resolve_op); + + typedef typename Protocol::endpoint endpoint_type; + typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; + typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type; + + winrt_resolve_op(const query_type& query, Handler& handler) + : winrt_async_op< + Windows::Foundation::Collections::IVectorView< + Windows::Networking::EndpointPair^>^>( + &winrt_resolve_op::do_complete), + query_(query), + handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) + { + } + + static void do_complete(io_service_impl* owner, operation* base, + const boost::system::error_code&, std::size_t) + { + // Take ownership of the operation object. + winrt_resolve_op* o(static_cast<winrt_resolve_op*>(base)); + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; + + BOOST_ASIO_HANDLER_COMPLETION((o)); + + iterator_type iterator = iterator_type(); + if (!o->ec_) + { + try + { + iterator = iterator_type::create( + o->result_, o->query_.hints(), + o->query_.host_name(), o->query_.service_name()); + } + catch (Platform::Exception^ e) + { + o->ec_ = boost::system::error_code(e->HResult, + boost::system::system_category()); + } + } + + // Make a copy of the handler so that the memory can be deallocated before + // the upcall is made. Even if we're not about to make an upcall, a + // sub-object of the handler may be the true owner of the memory associated + // with the handler. Consequently, a local copy of the handler is required + // to ensure that any owning sub-object remains valid until after we have + // deallocated the memory here. + detail::binder2<Handler, boost::system::error_code, iterator_type> + handler(o->handler_, o->ec_, iterator); + p.h = boost::asio::detail::addressof(handler.handler_); + p.reset(); + + // Make the upcall if required. + if (owner) + { + fenced_block b(fenced_block::half); + BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); + boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); + BOOST_ASIO_HANDLER_INVOCATION_END; + } + } + +private: + query_type query_; + Handler handler_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp new file mode 100644 index 0000000..624305f --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp @@ -0,0 +1,185 @@ +// +// detail/winrt_resolver_service.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP +#define BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/ip/basic_resolver_iterator.hpp> +#include <boost/asio/ip/basic_resolver_query.hpp> +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/socket_ops.hpp> +#include <boost/asio/detail/winrt_async_manager.hpp> +#include <boost/asio/detail/winrt_resolve_op.hpp> +#include <boost/asio/detail/winrt_utils.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Protocol> +class winrt_resolver_service +{ +public: + // The implementation type of the resolver. A cancellation token is used to + // indicate to the asynchronous operation that the operation has been + // cancelled. + typedef socket_ops::shared_cancel_token_type implementation_type; + + // The endpoint type. + typedef typename Protocol::endpoint endpoint_type; + + // The query type. + typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; + + // The iterator type. + typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type; + + // Constructor. + winrt_resolver_service(boost::asio::io_service& io_service) + : io_service_(use_service<io_service_impl>(io_service)), + async_manager_(use_service<winrt_async_manager>(io_service)) + { + } + + // Destructor. + ~winrt_resolver_service() + { + } + + // Destroy all user-defined handler objects owned by the service. + void shutdown_service() + { + } + + // Perform any fork-related housekeeping. + void fork_service(boost::asio::io_service::fork_event) + { + } + + // Construct a new resolver implementation. + void construct(implementation_type&) + { + } + + // Destroy a resolver implementation. + void destroy(implementation_type&) + { + } + + // Cancel pending asynchronous operations. + void cancel(implementation_type&) + { + } + + // Resolve a query to a list of entries. + iterator_type resolve(implementation_type&, + const query_type& query, boost::system::error_code& ec) + { + try + { + using namespace Windows::Networking::Sockets; + auto endpoint_pairs = async_manager_.sync( + DatagramSocket::GetEndpointPairsAsync( + winrt_utils::host_name(query.host_name()), + winrt_utils::string(query.service_name())), ec); + + if (ec) + return iterator_type(); + + return iterator_type::create( + endpoint_pairs, query.hints(), + query.host_name(), query.service_name()); + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + return iterator_type(); + } + } + + // Asynchronously resolve a query to a list of entries. + template <typename Handler> + void async_resolve(implementation_type&, + const query_type& query, Handler& handler) + { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + + // Allocate and construct an operation to wrap the handler. + typedef winrt_resolve_op<Protocol, Handler> op; + typename op::ptr p = { boost::asio::detail::addressof(handler), + boost_asio_handler_alloc_helpers::allocate( + sizeof(op), handler), 0 }; + p.p = new (p.v) op(query, handler); + + BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve")); + + try + { + using namespace Windows::Networking::Sockets; + async_manager_.async(DatagramSocket::GetEndpointPairsAsync( + winrt_utils::host_name(query.host_name()), + winrt_utils::string(query.service_name())), p.p); + p.v = p.p = 0; + } + catch (Platform::Exception^ e) + { + p.p->ec_ = boost::system::error_code( + e->HResult, boost::system::system_category()); + io_service_.post_immediate_completion(p.p, is_continuation); + p.v = p.p = 0; + } + } + + // Resolve an endpoint to a list of entries. + iterator_type resolve(implementation_type&, + const endpoint_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return iterator_type(); + } + + // Asynchronously resolve an endpoint to a list of entries. + template <typename Handler> + void async_resolve(implementation_type&, + const endpoint_type&, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const iterator_type iterator; + io_service_.get_io_service().post( + detail::bind_handler(handler, ec, iterator)); + } + +private: + io_service_impl& io_service_; + winrt_async_manager& async_manager_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp new file mode 100644 index 0000000..0e3f230 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp @@ -0,0 +1,92 @@ +// +// detail/winrt_socket_connect_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP +#define BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/buffer_sequence_adapter.hpp> +#include <boost/asio/detail/fenced_block.hpp> +#include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/error.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Handler> +class winrt_socket_connect_op : + public winrt_async_op<void> +{ +public: + BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_connect_op); + + winrt_socket_connect_op(Handler& handler) + : winrt_async_op<void>(&winrt_socket_connect_op::do_complete), + handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) + { + } + + static void do_complete(io_service_impl* owner, operation* base, + const boost::system::error_code&, std::size_t) + { + // Take ownership of the operation object. + winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op*>(base)); + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; + + BOOST_ASIO_HANDLER_COMPLETION((o)); + + // Make a copy of the handler so that the memory can be deallocated before + // the upcall is made. Even if we're not about to make an upcall, a + // sub-object of the handler may be the true owner of the memory associated + // with the handler. Consequently, a local copy of the handler is required + // to ensure that any owning sub-object remains valid until after we have + // deallocated the memory here. + detail::binder1<Handler, boost::system::error_code> + handler(o->handler_, o->ec_); + p.h = boost::asio::detail::addressof(handler.handler_); + p.reset(); + + // Make the upcall if required. + if (owner) + { + fenced_block b(fenced_block::half); + BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); + boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); + BOOST_ASIO_HANDLER_INVOCATION_END; + } + } + +private: + Handler handler_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp new file mode 100644 index 0000000..5654568 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp @@ -0,0 +1,112 @@ +// +// detail/winrt_socket_recv_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP +#define BOOST_ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/buffer_sequence_adapter.hpp> +#include <boost/asio/detail/fenced_block.hpp> +#include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/error.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename MutableBufferSequence, typename Handler> +class winrt_socket_recv_op : + public winrt_async_op<Windows::Storage::Streams::IBuffer^> +{ +public: + BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_recv_op); + + winrt_socket_recv_op(const MutableBufferSequence& buffers, Handler& handler) + : winrt_async_op<Windows::Storage::Streams::IBuffer^>( + &winrt_socket_recv_op::do_complete), + buffers_(buffers), + handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) + { + } + + static void do_complete(io_service_impl* owner, operation* base, + const boost::system::error_code&, std::size_t) + { + // Take ownership of the operation object. + winrt_socket_recv_op* o(static_cast<winrt_socket_recv_op*>(base)); + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; + + BOOST_ASIO_HANDLER_COMPLETION((o)); + +#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) + // Check whether buffers are still valid. + if (owner) + { + buffer_sequence_adapter<boost::asio::mutable_buffer, + MutableBufferSequence>::validate(o->buffers_); + } +#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) + + std::size_t bytes_transferred = o->result_ ? o->result_->Length : 0; + if (bytes_transferred == 0 && !o->ec_ && + !buffer_sequence_adapter<boost::asio::mutable_buffer, + MutableBufferSequence>::all_empty(o->buffers_)) + { + o->ec_ = boost::asio::error::eof; + } + + // Make a copy of the handler so that the memory can be deallocated before + // the upcall is made. Even if we're not about to make an upcall, a + // sub-object of the handler may be the true owner of the memory associated + // with the handler. Consequently, a local copy of the handler is required + // to ensure that any owning sub-object remains valid until after we have + // deallocated the memory here. + detail::binder2<Handler, boost::system::error_code, std::size_t> + handler(o->handler_, o->ec_, bytes_transferred); + p.h = boost::asio::detail::addressof(handler.handler_); + p.reset(); + + // Make the upcall if required. + if (owner) + { + fenced_block b(fenced_block::half); + BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); + boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); + BOOST_ASIO_HANDLER_INVOCATION_END; + } + } + +private: + MutableBufferSequence buffers_; + Handler handler_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp new file mode 100644 index 0000000..ef36766 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp @@ -0,0 +1,103 @@ +// +// detail/winrt_socket_send_op.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP +#define BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/bind_handler.hpp> +#include <boost/asio/detail/buffer_sequence_adapter.hpp> +#include <boost/asio/detail/fenced_block.hpp> +#include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_invoke_helpers.hpp> +#include <boost/asio/detail/winrt_async_op.hpp> +#include <boost/asio/error.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename ConstBufferSequence, typename Handler> +class winrt_socket_send_op : + public winrt_async_op<unsigned int> +{ +public: + BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_send_op); + + winrt_socket_send_op(const ConstBufferSequence& buffers, Handler& handler) + : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete), + buffers_(buffers), + handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) + { + } + + static void do_complete(io_service_impl* owner, operation* base, + const boost::system::error_code&, std::size_t) + { + // Take ownership of the operation object. + winrt_socket_send_op* o(static_cast<winrt_socket_send_op*>(base)); + ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; + + BOOST_ASIO_HANDLER_COMPLETION((o)); + +#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) + // Check whether buffers are still valid. + if (owner) + { + buffer_sequence_adapter<boost::asio::const_buffer, + ConstBufferSequence>::validate(o->buffers_); + } +#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) + + // Make a copy of the handler so that the memory can be deallocated before + // the upcall is made. Even if we're not about to make an upcall, a + // sub-object of the handler may be the true owner of the memory associated + // with the handler. Consequently, a local copy of the handler is required + // to ensure that any owning sub-object remains valid until after we have + // deallocated the memory here. + detail::binder2<Handler, boost::system::error_code, std::size_t> + handler(o->handler_, o->ec_, o->result_); + p.h = boost::asio::detail::addressof(handler.handler_); + p.reset(); + + // Make the upcall if required. + if (owner) + { + fenced_block b(fenced_block::half); + BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); + boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); + BOOST_ASIO_HANDLER_INVOCATION_END; + } + } + +private: + ConstBufferSequence buffers_; + Handler handler_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp new file mode 100644 index 0000000..a701efa --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp @@ -0,0 +1,234 @@ +// +// detail/winrt_ssocket_service.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP +#define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/error.hpp> +#include <boost/asio/io_service.hpp> +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/winrt_socket_connect_op.hpp> +#include <boost/asio/detail/winrt_ssocket_service_base.hpp> +#include <boost/asio/detail/winrt_utils.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +template <typename Protocol> +class winrt_ssocket_service : + public winrt_ssocket_service_base +{ +public: + // The protocol type. + typedef Protocol protocol_type; + + // The endpoint type. + typedef typename Protocol::endpoint endpoint_type; + + // The native type of a socket. + typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type; + + // The implementation type of the socket. + struct implementation_type : base_implementation_type + { + // Default constructor. + implementation_type() + : base_implementation_type(), + protocol_(endpoint_type().protocol()) + { + } + + // The protocol associated with the socket. + protocol_type protocol_; + }; + + // Constructor. + winrt_ssocket_service(boost::asio::io_service& io_service) + : winrt_ssocket_service_base(io_service) + { + } + + // Move-construct a new socket implementation. + void move_construct(implementation_type& impl, + implementation_type& other_impl) + { + this->base_move_construct(impl, other_impl); + + impl.protocol_ = other_impl.protocol_; + other_impl.protocol_ = endpoint_type().protocol(); + } + + // Move-assign from another socket implementation. + void move_assign(implementation_type& impl, + winrt_ssocket_service& other_service, + implementation_type& other_impl) + { + this->base_move_assign(impl, other_service, other_impl); + + impl.protocol_ = other_impl.protocol_; + other_impl.protocol_ = endpoint_type().protocol(); + } + + // Move-construct a new socket implementation from another protocol type. + template <typename Protocol1> + void converting_move_construct(implementation_type& impl, + typename winrt_ssocket_service< + Protocol1>::implementation_type& other_impl) + { + this->base_move_construct(impl, other_impl); + + impl.protocol_ = protocol_type(other_impl.protocol_); + other_impl.protocol_ = typename Protocol1::endpoint().protocol(); + } + + // Open a new socket implementation. + boost::system::error_code open(implementation_type& impl, + const protocol_type& protocol, boost::system::error_code& ec) + { + if (is_open(impl)) + { + ec = boost::asio::error::already_open; + return ec; + } + + try + { + impl.socket_ = ref new Windows::Networking::Sockets::StreamSocket; + impl.protocol_ = protocol; + ec = boost::system::error_code(); + } + catch (Platform::Exception^ e) + { + ec = boost::system::error_code(e->HResult, + boost::system::system_category()); + } + + return ec; + } + + // Assign a native socket to a socket implementation. + boost::system::error_code assign(implementation_type& impl, + const protocol_type& protocol, const native_handle_type& native_socket, + boost::system::error_code& ec) + { + if (is_open(impl)) + { + ec = boost::asio::error::already_open; + return ec; + } + + impl.socket_ = native_socket; + impl.protocol_ = protocol; + ec = boost::system::error_code(); + + return ec; + } + + // Bind the socket to the specified local endpoint. + boost::system::error_code bind(implementation_type&, + const endpoint_type&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Get the local endpoint. + endpoint_type local_endpoint(const implementation_type& impl, + boost::system::error_code& ec) const + { + endpoint_type endpoint; + endpoint.resize(do_get_endpoint(impl, true, + endpoint.data(), endpoint.size(), ec)); + return endpoint; + } + + // Get the remote endpoint. + endpoint_type remote_endpoint(const implementation_type& impl, + boost::system::error_code& ec) const + { + endpoint_type endpoint; + endpoint.resize(do_get_endpoint(impl, false, + endpoint.data(), endpoint.size(), ec)); + return endpoint; + } + + // Set a socket option. + template <typename Option> + boost::system::error_code set_option(implementation_type& impl, + const Option& option, boost::system::error_code& ec) + { + return do_set_option(impl, option.level(impl.protocol_), + option.name(impl.protocol_), option.data(impl.protocol_), + option.size(impl.protocol_), ec); + } + + // Get a socket option. + template <typename Option> + boost::system::error_code get_option(const implementation_type& impl, + Option& option, boost::system::error_code& ec) const + { + std::size_t size = option.size(impl.protocol_); + do_get_option(impl, option.level(impl.protocol_), + option.name(impl.protocol_), + option.data(impl.protocol_), &size, ec); + if (!ec) + option.resize(impl.protocol_, size); + return ec; + } + + // Connect the socket to the specified endpoint. + boost::system::error_code connect(implementation_type& impl, + const endpoint_type& peer_endpoint, boost::system::error_code& ec) + { + return do_connect(impl, peer_endpoint.data(), ec); + } + + // Start an asynchronous connect. + template <typename Handler> + void async_connect(implementation_type& impl, + const endpoint_type& peer_endpoint, Handler& handler) + { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + + // Allocate and construct an operation to wrap the handler. + typedef winrt_socket_connect_op<Handler> op; + typename op::ptr p = { boost::asio::detail::addressof(handler), + boost_asio_handler_alloc_helpers::allocate( + sizeof(op), handler), 0 }; + p.p = new (p.v) op(handler); + + BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect")); + + start_connect_op(impl, peer_endpoint.data(), p.p, is_continuation); + p.v = p.p = 0; + } +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp new file mode 100644 index 0000000..02469ef --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp @@ -0,0 +1,357 @@ +// +// detail/winrt_ssocket_service_base.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP +#define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <boost/asio/buffer.hpp> +#include <boost/asio/error.hpp> +#include <boost/asio/io_service.hpp> +#include <boost/asio/socket_base.hpp> +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/buffer_sequence_adapter.hpp> +#include <boost/asio/detail/socket_types.hpp> +#include <boost/asio/detail/winrt_async_manager.hpp> +#include <boost/asio/detail/winrt_socket_recv_op.hpp> +#include <boost/asio/detail/winrt_socket_send_op.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class winrt_ssocket_service_base +{ +public: + // The native type of a socket. + typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type; + + // The implementation type of the socket. + struct base_implementation_type + { + // Default constructor. + base_implementation_type() + : socket_(nullptr), + next_(0), + prev_(0) + { + } + + // The underlying native socket. + native_handle_type socket_; + + // Pointers to adjacent socket implementations in linked list. + base_implementation_type* next_; + base_implementation_type* prev_; + }; + + // Constructor. + BOOST_ASIO_DECL winrt_ssocket_service_base( + boost::asio::io_service& io_service); + + // Destroy all user-defined handler objects owned by the service. + BOOST_ASIO_DECL void shutdown_service(); + + // Construct a new socket implementation. + BOOST_ASIO_DECL void construct(base_implementation_type&); + + // Move-construct a new socket implementation. + BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl, + base_implementation_type& other_impl); + + // Move-assign from another socket implementation. + BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl, + winrt_ssocket_service_base& other_service, + base_implementation_type& other_impl); + + // Destroy a socket implementation. + BOOST_ASIO_DECL void destroy(base_implementation_type& impl); + + // Determine whether the socket is open. + bool is_open(const base_implementation_type& impl) const + { + return impl.socket_ != nullptr; + } + + // Destroy a socket implementation. + BOOST_ASIO_DECL boost::system::error_code close( + base_implementation_type& impl, boost::system::error_code& ec); + + // Get the native socket representation. + native_handle_type native_handle(base_implementation_type& impl) + { + return impl.socket_; + } + + // Cancel all operations associated with the socket. + boost::system::error_code cancel(base_implementation_type&, + boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Determine whether the socket is at the out-of-band data mark. + bool at_mark(const base_implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return false; + } + + // Determine the number of bytes available for reading. + std::size_t available(const base_implementation_type&, + boost::system::error_code& ec) const + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Perform an IO control command on the socket. + template <typename IO_Control_Command> + boost::system::error_code io_control(base_implementation_type&, + IO_Control_Command&, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Gets the non-blocking mode of the socket. + bool non_blocking(const base_implementation_type&) const + { + return false; + } + + // Sets the non-blocking mode of the socket. + boost::system::error_code non_blocking(base_implementation_type&, + bool, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Gets the non-blocking mode of the native socket implementation. + bool native_non_blocking(const base_implementation_type&) const + { + return false; + } + + // Sets the non-blocking mode of the native socket implementation. + boost::system::error_code native_non_blocking(base_implementation_type&, + bool, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Disable sends or receives on the socket. + boost::system::error_code shutdown(base_implementation_type&, + socket_base::shutdown_type, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return ec; + } + + // Send the given data to the peer. + template <typename ConstBufferSequence> + std::size_t send(base_implementation_type& impl, + const ConstBufferSequence& buffers, + socket_base::message_flags flags, boost::system::error_code& ec) + { + return do_send(impl, + buffer_sequence_adapter<boost::asio::const_buffer, + ConstBufferSequence>::first(buffers), flags, ec); + } + + // Wait until data can be sent without blocking. + std::size_t send(base_implementation_type&, const null_buffers&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous send. The data being sent must be valid for the + // lifetime of the asynchronous operation. + template <typename ConstBufferSequence, typename Handler> + void async_send(base_implementation_type& impl, + const ConstBufferSequence& buffers, + socket_base::message_flags flags, Handler& handler) + { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + + // Allocate and construct an operation to wrap the handler. + typedef winrt_socket_send_op<ConstBufferSequence, Handler> op; + typename op::ptr p = { boost::asio::detail::addressof(handler), + boost_asio_handler_alloc_helpers::allocate( + sizeof(op), handler), 0 }; + p.p = new (p.v) op(buffers, handler); + + BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send")); + + start_send_op(impl, + buffer_sequence_adapter<boost::asio::const_buffer, + ConstBufferSequence>::first(buffers), + flags, p.p, is_continuation); + p.v = p.p = 0; + } + + // Start an asynchronous wait until data can be sent without blocking. + template <typename Handler> + void async_send(base_implementation_type&, const null_buffers&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.get_io_service().post( + detail::bind_handler(handler, ec, bytes_transferred)); + } + + // Receive some data from the peer. Returns the number of bytes received. + template <typename MutableBufferSequence> + std::size_t receive(base_implementation_type& impl, + const MutableBufferSequence& buffers, + socket_base::message_flags flags, boost::system::error_code& ec) + { + return do_receive(impl, + buffer_sequence_adapter<boost::asio::mutable_buffer, + MutableBufferSequence>::first(buffers), flags, ec); + } + + // Wait until data can be received without blocking. + std::size_t receive(base_implementation_type&, const null_buffers&, + socket_base::message_flags, boost::system::error_code& ec) + { + ec = boost::asio::error::operation_not_supported; + return 0; + } + + // Start an asynchronous receive. The buffer for the data being received + // must be valid for the lifetime of the asynchronous operation. + template <typename MutableBufferSequence, typename Handler> + void async_receive(base_implementation_type& impl, + const MutableBufferSequence& buffers, + socket_base::message_flags flags, Handler& handler) + { + bool is_continuation = + boost_asio_handler_cont_helpers::is_continuation(handler); + + // Allocate and construct an operation to wrap the handler. + typedef winrt_socket_recv_op<MutableBufferSequence, Handler> op; + typename op::ptr p = { boost::asio::detail::addressof(handler), + boost_asio_handler_alloc_helpers::allocate( + sizeof(op), handler), 0 }; + p.p = new (p.v) op(buffers, handler); + + BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive")); + + start_receive_op(impl, + buffer_sequence_adapter<boost::asio::mutable_buffer, + MutableBufferSequence>::first(buffers), + flags, p.p, is_continuation); + p.v = p.p = 0; + } + + // Wait until data can be received without blocking. + template <typename Handler> + void async_receive(base_implementation_type&, const null_buffers&, + socket_base::message_flags, Handler& handler) + { + boost::system::error_code ec = boost::asio::error::operation_not_supported; + const std::size_t bytes_transferred = 0; + io_service_.get_io_service().post( + detail::bind_handler(handler, ec, bytes_transferred)); + } + +protected: + // Helper function to obtain endpoints associated with the connection. + BOOST_ASIO_DECL std::size_t do_get_endpoint( + const base_implementation_type& impl, bool local, + void* addr, std::size_t addr_len, boost::system::error_code& ec) const; + + // Helper function to set a socket option. + BOOST_ASIO_DECL boost::system::error_code do_set_option( + base_implementation_type& impl, + int level, int optname, const void* optval, + std::size_t optlen, boost::system::error_code& ec); + + // Helper function to get a socket option. + BOOST_ASIO_DECL void do_get_option( + const base_implementation_type& impl, + int level, int optname, void* optval, + std::size_t* optlen, boost::system::error_code& ec) const; + + // Helper function to perform a synchronous connect. + BOOST_ASIO_DECL boost::system::error_code do_connect( + base_implementation_type& impl, + const void* addr, boost::system::error_code& ec); + + // Helper function to start an asynchronous connect. + BOOST_ASIO_DECL void start_connect_op( + base_implementation_type& impl, const void* addr, + winrt_async_op<void>* op, bool is_continuation); + + // Helper function to perform a synchronous send. + BOOST_ASIO_DECL std::size_t do_send( + base_implementation_type& impl, const boost::asio::const_buffer& data, + socket_base::message_flags flags, boost::system::error_code& ec); + + // Helper function to start an asynchronous send. + BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl, + const boost::asio::const_buffer& data, socket_base::message_flags flags, + winrt_async_op<unsigned int>* op, bool is_continuation); + + // Helper function to perform a synchronous receive. + BOOST_ASIO_DECL std::size_t do_receive( + base_implementation_type& impl, const boost::asio::mutable_buffer& data, + socket_base::message_flags flags, boost::system::error_code& ec); + + // Helper function to start an asynchronous receive. + BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl, + const boost::asio::mutable_buffer& data, socket_base::message_flags flags, + winrt_async_op<Windows::Storage::Streams::IBuffer^>* op, + bool is_continuation); + + // The io_service implementation used for delivering completions. + io_service_impl& io_service_; + + // The manager that keeps track of outstanding operations. + winrt_async_manager& async_manager_; + + // Mutex to protect access to the linked list of implementations. + boost::asio::detail::mutex mutex_; + + // The head of a linked list of all implementations. + base_implementation_type* impl_list_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#if defined(BOOST_ASIO_HEADER_ONLY) +# include <boost/asio/detail/impl/winrt_ssocket_service_base.ipp> +#endif // defined(BOOST_ASIO_HEADER_ONLY) + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp new file mode 100644 index 0000000..9cadeca --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp @@ -0,0 +1,133 @@ +// +// detail/winrt_timer_scheduler.hpp +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP +#define BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <cstddef> +#include <boost/asio/detail/event.hpp> +#include <boost/asio/detail/limits.hpp> +#include <boost/asio/detail/mutex.hpp> +#include <boost/asio/detail/op_queue.hpp> +#include <boost/asio/detail/thread.hpp> +#include <boost/asio/detail/timer_queue_base.hpp> +#include <boost/asio/detail/timer_queue_set.hpp> +#include <boost/asio/detail/wait_op.hpp> +#include <boost/asio/io_service.hpp> + +#if defined(BOOST_ASIO_HAS_IOCP) +# include <boost/asio/detail/thread.hpp> +#endif // defined(BOOST_ASIO_HAS_IOCP) + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { + +class winrt_timer_scheduler + : public boost::asio::detail::service_base<winrt_timer_scheduler> +{ +public: + // Constructor. + BOOST_ASIO_DECL winrt_timer_scheduler(boost::asio::io_service& io_service); + + // Destructor. + BOOST_ASIO_DECL ~winrt_timer_scheduler(); + + // Destroy all user-defined handler objects owned by the service. + BOOST_ASIO_DECL void shutdown_service(); + + // Recreate internal descriptors following a fork. + BOOST_ASIO_DECL void fork_service( + boost::asio::io_service::fork_event fork_ev); + + // Initialise the task. No effect as this class uses its own thread. + BOOST_ASIO_DECL void init_task(); + + // Add a new timer queue to the reactor. + template <typename Time_Traits> + void add_timer_queue(timer_queue<Time_Traits>& queue); + + // Remove a timer queue from the reactor. + template <typename Time_Traits> + void remove_timer_queue(timer_queue<Time_Traits>& queue); + + // Schedule a new operation in the given timer queue to expire at the + // specified absolute time. + template <typename Time_Traits> + void schedule_timer(timer_queue<Time_Traits>& queue, + const typename Time_Traits::time_type& time, + typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); + + // Cancel the timer operations associated with the given token. Returns the + // number of operations that have been posted or dispatched. + template <typename Time_Traits> + std::size_t cancel_timer(timer_queue<Time_Traits>& queue, + typename timer_queue<Time_Traits>::per_timer_data& timer, + std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); + +private: + // Run the select loop in the thread. + BOOST_ASIO_DECL void run_thread(); + + // Entry point for the select loop thread. + BOOST_ASIO_DECL static void call_run_thread(winrt_timer_scheduler* reactor); + + // Helper function to add a new timer queue. + BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); + + // Helper function to remove a timer queue. + BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); + + // The io_service implementation used to post completions. + io_service_impl& io_service_; + + // Mutex used to protect internal variables. + boost::asio::detail::mutex mutex_; + + // Event used to wake up background thread. + boost::asio::detail::event event_; + + // The timer queues. + timer_queue_set timer_queues_; + + // The background thread that is waiting for timers to expire. + boost::asio::detail::thread* thread_; + + // Does the background thread need to stop. + bool stop_thread_; + + // Whether the service has been shut down. + bool shutdown_; +}; + +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#include <boost/asio/detail/impl/winrt_timer_scheduler.hpp> +#if defined(BOOST_ASIO_HEADER_ONLY) +# include <boost/asio/detail/impl/winrt_timer_scheduler.ipp> +#endif // defined(BOOST_ASIO_HEADER_ONLY) + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp new file mode 100644 index 0000000..3b10b07 --- /dev/null +++ b/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp @@ -0,0 +1,108 @@ +// +// detail/winrt_utils.hpp +// ~~~~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// 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_ASIO_DETAIL_WINRT_UTILS_HPP +#define BOOST_ASIO_DETAIL_WINRT_UTILS_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include <boost/asio/detail/config.hpp> + +#if defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#include <codecvt> +#include <cstdlib> +#include <future> +#include <locale> +#include <memory> +#include <robuffer.h> +#include <windows.storage.streams.h> +#include <wrl/implements.h> +#include <boost/asio/buffer.hpp> +#include <boost/system/error_code.hpp> +#include <boost/asio/detail/addressof.hpp> +#include <boost/asio/detail/socket_ops.hpp> + +#include <boost/asio/detail/push_options.hpp> + +namespace boost { +namespace asio { +namespace detail { +namespace winrt_utils { + +inline Platform::String^ string(const char* from) +{ + std::wstring tmp(from, from + std::strlen(from)); + return ref new Platform::String(tmp.c_str()); +} + +inline Platform::String^ string(const std::string& from) +{ + std::wstring tmp(from.begin(), from.end()); + return ref new Platform::String(tmp.c_str()); +} + +inline std::string string(Platform::String^ from) +{ + std::wstring_convert<std::codecvt_utf8<wchar_t>> converter; + return converter.to_bytes(from->Data()); +} + +inline Platform::String^ string(unsigned short from) +{ + return string(std::to_string(from)); +} + +template <typename T> +inline Platform::String^ string(const T& from) +{ + return string(from.to_string()); +} + +inline int integer(Platform::String^ from) +{ + return _wtoi(from->Data()); +} + +template <typename T> +inline Windows::Networking::HostName^ host_name(const T& from) +{ + return ref new Windows::Networking::HostName((string)(from)); +} + +template <typename ConstBufferSequence> +inline Windows::Storage::Streams::IBuffer^ buffer_dup( + const ConstBufferSequence& buffers) +{ + using Microsoft::WRL::ComPtr; + std::size_t size = boost::asio::buffer_size(buffers); + auto b = ref new Windows::Storage::Streams::Buffer(size); + ComPtr<IInspectable> insp = reinterpret_cast<IInspectable*>(b); + ComPtr<Windows::Storage::Streams::IBufferByteAccess> bacc; + insp.As(&bacc); + byte* bytes = nullptr; + bacc->Buffer(&bytes); + boost::asio::buffer_copy(boost::asio::buffer(bytes, size), buffers); + b->Length = size; + return b; +} + +} // namespace winrt_utils +} // namespace detail +} // namespace asio +} // namespace boost + +#include <boost/asio/detail/pop_options.hpp> + +#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) + +#endif // BOOST_ASIO_DETAIL_WINRT_UTILS_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp index 702ba71..aef74f0 100644 --- a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp @@ -1,11 +1,11 @@ // // detail/winsock_init.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WINSOCK_INIT_HPP @@ -14,13 +14,13 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> -#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { @@ -36,14 +36,18 @@ protected: long result_; }; BOOST_ASIO_DECL static void startup(data& d, unsigned char major, unsigned char minor); + BOOST_ASIO_DECL static void manual_startup(data& d); + BOOST_ASIO_DECL static void cleanup(data& d); + BOOST_ASIO_DECL static void manual_cleanup(data& d); + BOOST_ASIO_DECL static void throw_on_error(data& d); }; template <int Major = 2, int Minor = 0> class winsock_init : private winsock_init_base { @@ -63,13 +67,47 @@ public: ~winsock_init() { cleanup(data_); } + // This class may be used to indicate that user code will manage Winsock + // initialisation and cleanup. This may be required in the case of a DLL, for + // example, where it is not safe to initialise Winsock from global object + // constructors. + // + // To prevent asio from initialising Winsock, the object must be constructed + // before any Asio's own global objects. With MSVC, this may be accomplished + // by adding the following code to the DLL: + // + // #pragma warning(push) + // #pragma warning(disable:4073) + // #pragma init_seg(lib) + // boost::asio::detail::winsock_init<>::manual manual_winsock_init; + // #pragma warning(pop) + class manual + { + public: + manual() + { + manual_startup(data_); + } + + manual(const manual&) + { + manual_startup(data_); + } + + ~manual() + { + manual_cleanup(data_); + } + }; + private: + friend class manual; static data data_; }; template <int Major, int Minor> winsock_init_base::data winsock_init<Major, Minor>::data_; @@ -84,9 +122,9 @@ static const winsock_init<>& winsock_init_instance = winsock_init<>(false); #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/winsock_init.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) -#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__) +#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP diff --git a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp index d82da22..0ff28ed 100644 --- a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp +++ b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp @@ -1,11 +1,11 @@ // // detail/wrapped_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // 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_ASIO_DETAIL_WRAPPED_HANDLER_HPP @@ -14,21 +14,41 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> +#include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { -template <typename Dispatcher, typename Handler> +struct is_continuation_delegated +{ + template <typename Dispatcher, typename Handler> + bool operator()(Dispatcher&, Handler& handler) const + { + return boost_asio_handler_cont_helpers::is_continuation(handler); + } +}; + +struct is_continuation_if_running +{ + template <typename Dispatcher, typename Handler> + bool operator()(Dispatcher& dispatcher, Handler&) const + { + return dispatcher.running_in_this_thread(); + } +}; + +template <typename Dispatcher, typename Handler, + typename IsContinuation = is_continuation_delegated> class wrapped_handler { public: typedef void result_type; wrapped_handler(Dispatcher dispatcher, Handler& handler) @@ -50,13 +70,13 @@ public: { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { - dispatcher_.dispatch(handler_); + dispatcher_.dispatch(BOOST_ASIO_MOVE_CAST(Handler)(handler_)); } void operator()() const { dispatcher_.dispatch(handler_); } @@ -178,40 +198,49 @@ public: //private: Context context_; Handler handler_; }; -template <typename Dispatcher, typename Handler> +template <typename Dispatcher, typename Handler, typename IsContinuation> inline void* asio_handler_allocate(std::size_t size, - wrapped_handler<Dispatcher, Handler>* this_handler) + wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); } -template <typename Dispatcher, typename Handler> +template <typename Dispatcher, typename Handler, typename IsContinuation> inline void asio_handler_deallocate(void* pointer, std::size_t size, - wrapped_handler<Dispatcher, Handler>* this_handler) + wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); } -template <typename Function, typename Dispatcher, typename Handler> +template <typename Dispatcher, typename Handler, typename IsContinuation> +inline bool asio_handler_is_continuation( + wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) +{ + return IsContinuation()(this_handler->dispatcher_, this_handler->handler_); +} + +template <typename Function, typename Dispatcher, + typename Handler, typename IsContinuation> inline void asio_handler_invoke(Function& function, - wrapped_handler<Dispatcher, Handler>* this_handler) + wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { this_handler->dispatcher_.dispatch( rewrapped_handler<Function, Handler>( function, this_handler->handler_)); } -template <typename Function, typename Dispatcher, typename Handler> +template <typename Function, typename Dispatcher, + typename Handler, typename IsContinuation> inline void asio_handler_invoke(const Function& function, - wrapped_handler<Dispatcher, Handler>* this_handler) + wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { this_handler->dispatcher_.dispatch( rewrapped_handler<Function, Handler>( function, this_handler->handler_)); } @@ -228,12 +257,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size, rewrapped_handler<Handler, Context>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->context_); } +template <typename Dispatcher, typename Context> +inline bool asio_handler_is_continuation( + rewrapped_handler<Dispatcher, Context>* this_handler) +{ + return boost_asio_handler_cont_helpers::is_continuation( + this_handler->context_); +} + template <typename Function, typename Handler, typename Context> inline void asio_handler_invoke(Function& function, rewrapped_handler<Handler, Context>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->context_); |