Added boost header

test/external/boost/asio/impl/connect.hpp

@@ -0,0 +1,391 @@
+//
+// impl/connect.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_IMPL_CONNECT_HPP
+#define BOOST_ASIO_IMPL_CONNECT_HPP
+
+#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/consuming_buffers.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.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
+{
+  struct default_connect_condition
+  {
+    template <typename Iterator>
+    Iterator operator()(const boost::system::error_code&, Iterator next)
+    {
+      return next;
+    }
+  };
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, boost::system::error_code& ec)
+{
+  return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, end, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService, typename Iterator>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, boost::system::error_code& ec)
+{
+  return connect(s, begin, end, detail::default_connect_condition(), ec);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, connect_condition, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+inline Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    boost::system::error_code& ec)
+{
+  return connect(s, begin, Iterator(), connect_condition, ec);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition)
+{
+  boost::system::error_code ec;
+  Iterator result = connect(s, begin, end, connect_condition, ec);
+  boost::asio::detail::throw_error(ec, "connect");
+  return result;
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ConnectCondition>
+Iterator connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+
+  for (Iterator iter = begin; iter != end; ++iter)
+  {
+    iter = connect_condition(ec, iter);
+    if (iter != end)
+    {
+      s.close(ec);
+      s.connect(*iter, ec);
+      if (!ec)
+        return iter;
+    }
+  }
+
+  if (!ec)
+    ec = boost::asio::error::not_found;
+
+  return end;
+}
+
+namespace detail
+{
+  // Enable the empty base class optimisation for the connect condition.
+  template <typename ConnectCondition>
+  class base_from_connect_condition
+  {
+  protected:
+    explicit base_from_connect_condition(
+        const ConnectCondition& connect_condition)
+      : connect_condition_(connect_condition)
+    {
+    }
+
+    template <typename Iterator>
+    void check_condition(const boost::system::error_code& ec,
+        Iterator& iter, Iterator& end)
+    {
+      if (iter != end)
+        iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
+    }
+
+  private:
+    ConnectCondition connect_condition_;
+  };
+
+  // The default_connect_condition implementation is essentially a no-op. This
+  // template specialisation lets us eliminate all costs associated with it.
+  template <>
+  class base_from_connect_condition<default_connect_condition>
+  {
+  protected:
+    explicit base_from_connect_condition(const default_connect_condition&)
+    {
+    }
+
+    template <typename Iterator>
+    void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
+    {
+    }
+  };
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  class connect_op : base_from_connect_condition<ConnectCondition>
+  {
+  public:
+    connect_op(basic_socket<Protocol, SocketService>& sock,
+        const Iterator& begin, const Iterator& end,
+        const ConnectCondition& connect_condition,
+        ComposedConnectHandler& handler)
+      : base_from_connect_condition<ConnectCondition>(connect_condition),
+        socket_(sock),
+        iter_(begin),
+        end_(end),
+        handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    connect_op(const connect_op& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        iter_(other.iter_),
+        end_(other.end_),
+        handler_(other.handler_)
+    {
+    }
+
+    connect_op(connect_op&& other)
+      : base_from_connect_condition<ConnectCondition>(other),
+        socket_(other.socket_),
+        iter_(other.iter_),
+        end_(other.end_),
+        handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(boost::system::error_code ec, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        for (;;)
+        {
+          this->check_condition(ec, iter_, end_);
+
+          if (iter_ != end_)
+          {
+            socket_.close(ec);
+            socket_.async_connect(*iter_,
+                BOOST_ASIO_MOVE_CAST(connect_op)(*this));
+            return;
+          }
+
+          if (start)
+          {
+            ec = boost::asio::error::not_found;
+            socket_.get_io_service().post(detail::bind_handler(*this, ec));
+            return;
+          }
+
+          default:
+
+          if (iter_ == end_)
+            break;
+
+          if (!socket_.is_open())
+          {
+            ec = boost::asio::error::operation_aborted;
+            break;
+          }
+
+          if (!ec)
+            break;
+
+          ++iter_;
+        }
+
+        handler_(static_cast<const boost::system::error_code&>(ec),
+            static_cast<const Iterator&>(iter_));
+      }
+    }
+
+  //private:
+    basic_socket<Protocol, SocketService>& socket_;
+    Iterator iter_;
+    Iterator end_;
+    ComposedConnectHandler handler_;
+  };
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol,
+      typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_invoke(Function& function,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Protocol,
+      typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline void asio_handler_invoke(const Function& function,
+      connect_op<Protocol, SocketService, Iterator,
+        ConnectCondition, ComposedConnectHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Protocol, typename SocketService, typename Iterator,
+      typename ConnectCondition, typename ComposedConnectHandler>
+  inline connect_op<Protocol, SocketService, Iterator,
+      ConnectCondition, ComposedConnectHandler>
+  make_connect_op(basic_socket<Protocol, SocketService>& sock,
+      const Iterator& begin, const Iterator& end,
+      const ConnectCondition& connect_condition,
+      ComposedConnectHandler handler)
+  {
+    return connect_op<Protocol, SocketService, Iterator,
+      ConnectCondition, ComposedConnectHandler>(
+        sock, begin, end, connect_condition, handler);
+  }
+} // namespace detail
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, Iterator(),
+    detail::default_connect_condition(),
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+        boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService,
+    typename Iterator, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, end,
+    detail::default_connect_condition(),
+      BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+        boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+inline void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, Iterator(), connect_condition,
+    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+      boost::system::error_code(), 1);
+}
+
+template <typename Protocol, typename SocketService, typename Iterator,
+    typename ConnectCondition, typename ComposedConnectHandler>
+void async_connect(basic_socket<Protocol, SocketService>& s,
+    Iterator begin, Iterator end, ConnectCondition connect_condition,
+    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ComposedConnectHandler.
+  BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(
+      ComposedConnectHandler, handler, Iterator) type_check;
+
+  detail::make_connect_op(s, begin, end, connect_condition,
+    BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))(
+      boost::system::error_code(), 1);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_CONNECT_HPP

test/external/boost/asio/impl/error.ipp

@@ -0,0 +1,129 @@
+//
+// impl/error.ipp
+// ~~~~~~~~~~~~~~
+//
+// 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_IMPL_ERROR_IPP
+#define BOOST_ASIO_IMPL_ERROR_IPP
+
+#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/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace error {
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+namespace detail {
+
+class netdb_category : public boost::system::error_category
+{
+public:
+  const char* name() const
+  {
+    return "asio.netdb";
+  }
+
+  std::string message(int value) const
+  {
+    if (value == error::host_not_found)
+      return "Host not found (authoritative)";
+    if (value == error::host_not_found_try_again)
+      return "Host not found (non-authoritative), try again later";
+    if (value == error::no_data)
+      return "The query is valid, but it does not have associated data";
+    if (value == error::no_recovery)
+      return "A non-recoverable error occurred during database lookup";
+    return "asio.netdb error";
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_netdb_category()
+{
+  static detail::netdb_category instance;
+  return instance;
+}
+
+namespace detail {
+
+class addrinfo_category : public boost::system::error_category
+{
+public:
+  const char* name() const
+  {
+    return "asio.addrinfo";
+  }
+
+  std::string message(int value) const
+  {
+    if (value == error::service_not_found)
+      return "Service not found";
+    if (value == error::socket_type_not_supported)
+      return "Socket type not supported";
+    return "asio.addrinfo error";
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_addrinfo_category()
+{
+  static detail::addrinfo_category instance;
+  return instance;
+}
+
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+namespace detail {
+
+class misc_category : public boost::system::error_category
+{
+public:
+  const char* name() const
+  {
+    return "asio.misc";
+  }
+
+  std::string message(int value) const
+  {
+    if (value == error::already_open)
+      return "Already open";
+    if (value == error::eof)
+      return "End of file";
+    if (value == error::not_found)
+      return "Element not found";
+    if (value == error::fd_set_failure)
+      return "The descriptor does not fit into the select call's fd_set";
+    return "asio.misc error";
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_misc_category()
+{
+  static detail::misc_category instance;
+  return instance;
+}
+
+} // namespace error
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_ERROR_IPP

test/external/boost/asio/impl/io_service.hpp

@@ -0,0 +1,143 @@
+//
+// impl/io_service.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_IMPL_IO_SERVICE_HPP
+#define BOOST_ASIO_IMPL_IO_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/service_registry.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Service>
+inline Service& use_service(io_service& ios)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
+  (void)static_cast<const io_service::id*>(&Service::id);
+
+  return ios.service_registry_->template use_service<Service>();
+}
+
+template <>
+inline detail::io_service_impl& use_service<detail::io_service_impl>(
+    io_service& ios)
+{
+  return ios.impl_;
+}
+
+template <typename Service>
+inline void add_service(io_service& ios, Service* svc)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
+  (void)static_cast<const io_service::id*>(&Service::id);
+
+  ios.service_registry_->template add_service<Service>(svc);
+}
+
+template <typename Service>
+inline bool has_service(io_service& ios)
+{
+  // Check that Service meets the necessary type requirements.
+  (void)static_cast<io_service::service*>(static_cast<Service*>(0));
+  (void)static_cast<const io_service::id*>(&Service::id);
+
+  return ios.service_registry_->template has_service<Service>();
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_io_service.hpp>
+#else
+# include <boost/asio/detail/task_io_service.hpp>
+#endif
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename CompletionHandler>
+inline void io_service::dispatch(
+    BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a CompletionHandler.
+  BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+  impl_.dispatch(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+}
+
+template <typename CompletionHandler>
+inline void io_service::post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a CompletionHandler.
+  BOOST_ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
+
+  impl_.post(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+}
+
+template <typename Handler>
+#if defined(GENERATING_DOCUMENTATION)
+unspecified
+#else
+inline detail::wrapped_handler<io_service&, Handler>
+#endif
+io_service::wrap(Handler handler)
+{
+  return detail::wrapped_handler<io_service&, Handler>(*this, handler);
+}
+
+inline io_service::work::work(boost::asio::io_service& io_service)
+  : io_service_impl_(io_service.impl_)
+{
+  io_service_impl_.work_started();
+}
+
+inline io_service::work::work(const work& other)
+  : io_service_impl_(other.io_service_impl_)
+{
+  io_service_impl_.work_started();
+}
+
+inline io_service::work::~work()
+{
+  io_service_impl_.work_finished();
+}
+
+inline boost::asio::io_service& io_service::work::get_io_service()
+{
+  return io_service_impl_.get_io_service();
+}
+
+inline boost::asio::io_service& io_service::service::get_io_service()
+{
+  return owner_;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_IO_SERVICE_HPP

test/external/boost/asio/impl/io_service.ipp

@@ -0,0 +1,157 @@
+//
+// impl/io_service.ipp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// 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_IMPL_IO_SERVICE_IPP
+#define BOOST_ASIO_IMPL_IO_SERVICE_IPP
+
+#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/io_service.hpp>
+#include <boost/asio/detail/scoped_ptr.hpp>
+#include <boost/asio/detail/service_registry.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_io_service.hpp>
+#else
+# include <boost/asio/detail/task_io_service.hpp>
+#endif
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+io_service::io_service()
+  : service_registry_(new boost::asio::detail::service_registry(
+        *this, static_cast<impl_type*>(0),
+        (std::numeric_limits<std::size_t>::max)())),
+    impl_(service_registry_->first_service<impl_type>())
+{
+}
+
+io_service::io_service(std::size_t concurrency_hint)
+  : service_registry_(new boost::asio::detail::service_registry(
+        *this, static_cast<impl_type*>(0), concurrency_hint)),
+    impl_(service_registry_->first_service<impl_type>())
+{
+}
+
+io_service::~io_service()
+{
+  delete service_registry_;
+}
+
+std::size_t io_service::run()
+{
+  boost::system::error_code ec;
+  std::size_t s = impl_.run(ec);
+  boost::asio::detail::throw_error(ec);
+  return s;
+}
+
+std::size_t io_service::run(boost::system::error_code& ec)
+{
+  return impl_.run(ec);
+}
+
+std::size_t io_service::run_one()
+{
+  boost::system::error_code ec;
+  std::size_t s = impl_.run_one(ec);
+  boost::asio::detail::throw_error(ec);
+  return s;
+}
+
+std::size_t io_service::run_one(boost::system::error_code& ec)
+{
+  return impl_.run_one(ec);
+}
+
+std::size_t io_service::poll()
+{
+  boost::system::error_code ec;
+  std::size_t s = impl_.poll(ec);
+  boost::asio::detail::throw_error(ec);
+  return s;
+}
+
+std::size_t io_service::poll(boost::system::error_code& ec)
+{
+  return impl_.poll(ec);
+}
+
+std::size_t io_service::poll_one()
+{
+  boost::system::error_code ec;
+  std::size_t s = impl_.poll_one(ec);
+  boost::asio::detail::throw_error(ec);
+  return s;
+}
+
+std::size_t io_service::poll_one(boost::system::error_code& ec)
+{
+  return impl_.poll_one(ec);
+}
+
+void io_service::stop()
+{
+  impl_.stop();
+}
+
+bool io_service::stopped() const
+{
+  return impl_.stopped();
+}
+
+void io_service::reset()
+{
+  impl_.reset();
+}
+
+void io_service::notify_fork(boost::asio::io_service::fork_event event)
+{
+  service_registry_->notify_fork(event);
+}
+
+io_service::service::service(boost::asio::io_service& owner)
+  : owner_(owner),
+    next_(0)
+{
+}
+
+io_service::service::~service()
+{
+}
+
+void io_service::service::fork_service(boost::asio::io_service::fork_event)
+{
+}
+
+service_already_exists::service_already_exists()
+  : std::logic_error("Service already exists.")
+{
+}
+
+invalid_service_owner::invalid_service_owner()
+  : std::logic_error("Invalid service owner.")
+{
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_IO_SERVICE_IPP

test/external/boost/asio/impl/read.hpp

@@ -0,0 +1,696 @@
+//
+// impl/read.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_IMPL_READ_HPP
+#define BOOST_ASIO_IMPL_READ_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <algorithm>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_completion_cond.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/dependent_type.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename SyncReadStream, typename MutableBufferSequence,
+    typename CompletionCondition>
+std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  boost::asio::detail::consuming_buffers<
+    mutable_buffer, MutableBufferSequence> tmp(buffers);
+  std::size_t total_transferred = 0;
+  tmp.prepare(detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred)));
+  while (tmp.begin() != tmp.end())
+  {
+    std::size_t bytes_transferred = s.read_some(tmp, ec);
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    tmp.prepare(detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred)));
+  }
+  return total_transferred;
+}
+
+template <typename SyncReadStream, typename MutableBufferSequence>
+inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "read");
+  return bytes_transferred;
+}
+
+template <typename SyncReadStream, typename MutableBufferSequence>
+inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return read(s, buffers, transfer_all(), ec);
+}
+
+template <typename SyncReadStream, typename MutableBufferSequence,
+    typename CompletionCondition>
+inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "read");
+  return bytes_transferred;
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template <typename SyncReadStream, typename Allocator,
+    typename CompletionCondition>
+std::size_t read(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  std::size_t total_transferred = 0;
+  std::size_t max_size = detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred));
+  std::size_t bytes_available = read_size_helper(b, max_size);
+  while (bytes_available > 0)
+  {
+    std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
+    b.commit(bytes_transferred);
+    total_transferred += bytes_transferred;
+    max_size = detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred));
+    bytes_available = read_size_helper(b, max_size);
+  }
+  return total_transferred;
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read(s, b, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "read");
+  return bytes_transferred;
+}
+
+template <typename SyncReadStream, typename Allocator>
+inline std::size_t read(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return read(s, b, transfer_all(), ec);
+}
+
+template <typename SyncReadStream, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t read(SyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read(s, b, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "read");
+  return bytes_transferred;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  class read_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+        for (;;)
+        {
+          stream_.async_read_some(buffers_,
+              BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          buffers_.consume(bytes_transferred);
+          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+          if ((!ec && bytes_transferred == 0)
+              || buffers_.begin() == buffers_.end())
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncReadStream& stream_;
+    boost::asio::detail::consuming_buffers<
+      mutable_buffer, MutableBufferSequence> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncReadStream,
+      typename CompletionCondition, typename ReadHandler>
+  class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
+      CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_op(AsyncReadStream& stream,
+        const boost::asio::mutable_buffers_1& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          stream_.async_read_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncReadStream& stream_;
+    boost::asio::mutable_buffer buffer_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncReadStream, typename Elem,
+      typename CompletionCondition, typename ReadHandler>
+  class read_op<AsyncReadStream, boost::array<Elem, 2>,
+      CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
+        boost::asio::mutable_buffer(buffers_[0]),
+        boost::asio::mutable_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          stream_.async_read_some(bufs, BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncReadStream& stream_;
+    boost::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncReadStream, typename Elem,
+      typename CompletionCondition, typename ReadHandler>
+  class read_op<AsyncReadStream, std::array<Elem, 2>,
+      CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_op(const read_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_op(read_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
+        boost::asio::mutable_buffer(buffers_[0]),
+        boost::asio::mutable_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          stream_.async_read_some(bufs, BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncReadStream& stream_;
+    std::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      read_op<AsyncReadStream, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncReadStream, typename MutableBufferSequence,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_op<AsyncReadStream, MutableBufferSequence,
+      CompletionCondition, ReadHandler>
+  make_read_op(AsyncReadStream& s, const MutableBufferSequence& buffers,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_op<AsyncReadStream, MutableBufferSequence, CompletionCondition,
+      ReadHandler>(s, buffers, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncReadStream, typename MutableBufferSequence,
+    typename CompletionCondition, typename ReadHandler>
+inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_op(
+    s, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncReadStream, typename MutableBufferSequence,
+    typename ReadHandler>
+inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_op(
+    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  class read_streambuf_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_streambuf_op(AsyncReadStream& stream,
+        basic_streambuf<Allocator>& streambuf,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        streambuf_(streambuf),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_streambuf_op(const read_streambuf_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_streambuf_op(read_streambuf_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t max_size, bytes_available;
+      switch (start)
+      {
+        case 1:
+        max_size = this->check_for_completion(ec, total_transferred_);
+        bytes_available = read_size_helper(streambuf_, max_size);
+        for (;;)
+        {
+          stream_.async_read_some(streambuf_.prepare(bytes_available),
+              BOOST_ASIO_MOVE_CAST(read_streambuf_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          streambuf_.commit(bytes_transferred);
+          max_size = this->check_for_completion(ec, total_transferred_);
+          bytes_available = read_size_helper(streambuf_, max_size);
+          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncReadStream& stream_;
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncReadStream,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      read_streambuf_op<AsyncReadStream, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncReadStream, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_streambuf_op<AsyncReadStream, Allocator,
+      CompletionCondition, ReadHandler>
+  make_read_streambuf_op(
+      AsyncReadStream& s, boost::asio::basic_streambuf<Allocator>& b,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_streambuf_op<AsyncReadStream, Allocator, CompletionCondition,
+      ReadHandler>(s, b, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncReadStream, typename Allocator,
+    typename CompletionCondition, typename ReadHandler>
+inline void async_read(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_streambuf_op(
+    s, b, completion_condition, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
+inline void async_read(AsyncReadStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_streambuf_op(
+    s, b, transfer_all(), BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+      boost::system::error_code(), 0, 1);
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_READ_HPP

test/external/boost/asio/impl/read_at.hpp

@@ -0,0 +1,745 @@
+//
+// impl/read_at.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_IMPL_READ_AT_HPP
+#define BOOST_ASIO_IMPL_READ_AT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <algorithm>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_completion_cond.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/dependent_type.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
+    typename CompletionCondition>
+std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  boost::asio::detail::consuming_buffers<
+    mutable_buffer, MutableBufferSequence> tmp(buffers);
+  std::size_t total_transferred = 0;
+  tmp.prepare(detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred)));
+  while (tmp.begin() != tmp.end())
+  {
+    std::size_t bytes_transferred = d.read_some_at(
+        offset + total_transferred, tmp, ec);
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    tmp.prepare(detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred)));
+  }
+  return total_transferred;
+}
+
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read_at(
+      d, offset, buffers, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "read_at");
+  return bytes_transferred;
+}
+
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return read_at(d, offset, buffers, transfer_all(), ec);
+}
+
+template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
+    typename CompletionCondition>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read_at(
+      d, offset, buffers, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "read_at");
+  return bytes_transferred;
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template <typename SyncRandomAccessReadDevice, typename Allocator,
+    typename CompletionCondition>
+std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  std::size_t total_transferred = 0;
+  std::size_t max_size = detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred));
+  std::size_t bytes_available = read_size_helper(b, max_size);
+  while (bytes_available > 0)
+  {
+    std::size_t bytes_transferred = d.read_some_at(
+        offset + total_transferred, b.prepare(bytes_available), ec);
+    b.commit(bytes_transferred);
+    total_transferred += bytes_transferred;
+    max_size = detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred));
+    bytes_available = read_size_helper(b, max_size);
+  }
+  return total_transferred;
+}
+
+template <typename SyncRandomAccessReadDevice, typename Allocator>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read_at(
+      d, offset, b, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "read_at");
+  return bytes_transferred;
+}
+
+template <typename SyncRandomAccessReadDevice, typename Allocator>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return read_at(d, offset, b, transfer_all(), ec);
+}
+
+template <typename SyncRandomAccessReadDevice, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t read_at(SyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = read_at(
+      d, offset, b, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "read_at");
+  return bytes_transferred;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  class read_at_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_at_op(AsyncRandomAccessReadDevice& device,
+        boost::uint64_t offset, const MutableBufferSequence& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+        for (;;)
+        {
+          device_.async_read_some_at(offset_ + total_transferred_,
+              buffers_, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          buffers_.consume(bytes_transferred);
+          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+          if ((!ec && bytes_transferred == 0)
+              || buffers_.begin() == buffers_.end())
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessReadDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::detail::consuming_buffers<
+      mutable_buffer, MutableBufferSequence> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessReadDevice,
+      typename CompletionCondition, typename ReadHandler>
+  class read_at_op<AsyncRandomAccessReadDevice,
+      boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_at_op(AsyncRandomAccessReadDevice& device,
+        boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          device_.async_read_some_at(offset_ + total_transferred_,
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessReadDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::mutable_buffer buffer_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessReadDevice, typename Elem,
+      typename CompletionCondition, typename ReadHandler>
+  class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
+      CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_at_op(AsyncRandomAccessReadDevice& device,
+        boost::uint64_t offset, const boost::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
+        boost::asio::mutable_buffer(buffers_[0]),
+        boost::asio::mutable_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          device_.async_read_some_at(offset_ + total_transferred_,
+              bufs, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessReadDevice& device_;
+    boost::uint64_t offset_;
+    boost::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncRandomAccessReadDevice, typename Elem,
+      typename CompletionCondition, typename ReadHandler>
+  class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
+      CompletionCondition, ReadHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_at_op(AsyncRandomAccessReadDevice& device,
+        boost::uint64_t offset, const std::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_op(const read_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_op(read_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
+        boost::asio::mutable_buffer(buffers_[0]),
+        boost::asio::mutable_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          device_.async_read_some_at(offset_ + total_transferred_,
+              bufs, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessReadDevice& device_;
+    boost::uint64_t offset_;
+    std::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessReadDevice,
+      typename MutableBufferSequence, typename CompletionCondition,
+      typename ReadHandler>
+  inline read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, CompletionCondition, ReadHandler>
+  make_read_at_op(AsyncRandomAccessReadDevice& d,
+      boost::uint64_t offset, const MutableBufferSequence& buffers,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_at_op<AsyncRandomAccessReadDevice,
+      MutableBufferSequence, CompletionCondition, ReadHandler>(
+        d, offset, buffers, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
+    typename CompletionCondition, typename ReadHandler>
+inline void async_read_at(AsyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_op(
+    d, offset, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
+    typename ReadHandler>
+inline void async_read_at(AsyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, const MutableBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_op(
+    d, offset, buffers, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  class read_at_streambuf_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
+        boost::uint64_t offset, basic_streambuf<Allocator>& streambuf,
+        CompletionCondition completion_condition, ReadHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        streambuf_(streambuf),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    read_at_streambuf_op(const read_at_streambuf_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    read_at_streambuf_op(read_at_streambuf_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        streambuf_(other.streambuf_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t max_size, bytes_available;
+      switch (start)
+      {
+        case 1:
+        max_size = this->check_for_completion(ec, total_transferred_);
+        bytes_available = read_size_helper(streambuf_, max_size);
+        for (;;)
+        {
+          device_.async_read_some_at(offset_ + total_transferred_,
+              streambuf_.prepare(bytes_available),
+              BOOST_ASIO_MOVE_CAST(read_at_streambuf_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          streambuf_.commit(bytes_transferred);
+          max_size = this->check_for_completion(ec, total_transferred_);
+          bytes_available = read_size_helper(streambuf_, max_size);
+          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessReadDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    std::size_t total_transferred_;
+    ReadHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(Function& function,
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessReadDevice,
+      typename Allocator, typename CompletionCondition, typename ReadHandler>
+  inline void asio_handler_invoke(const Function& function,
+      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
+        CompletionCondition, ReadHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessReadDevice, typename Allocator,
+      typename CompletionCondition, typename ReadHandler>
+  inline read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Allocator, CompletionCondition, ReadHandler>
+  make_read_at_streambuf_op(AsyncRandomAccessReadDevice& d,
+      boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+      CompletionCondition completion_condition, ReadHandler handler)
+  {
+    return read_at_streambuf_op<AsyncRandomAccessReadDevice,
+      Allocator, CompletionCondition, ReadHandler>(
+        d, offset, b, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncRandomAccessReadDevice, typename Allocator,
+    typename CompletionCondition, typename ReadHandler>
+inline void async_read_at(AsyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_streambuf_op(
+    d, offset, b, completion_condition,
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncRandomAccessReadDevice, typename Allocator,
+    typename ReadHandler>
+inline void async_read_at(AsyncRandomAccessReadDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a ReadHandler.
+  BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
+
+  detail::make_read_at_streambuf_op(
+    d, offset, b, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_READ_AT_HPP

test/external/boost/asio/impl/serial_port_base.hpp

@@ -0,0 +1,61 @@
+//
+// impl/serial_port_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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)
+//
+
+#ifndef BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
+#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
+  : value_(rate)
+{
+}
+
+inline unsigned int serial_port_base::baud_rate::value() const
+{
+  return value_;
+}
+
+inline serial_port_base::flow_control::type
+serial_port_base::flow_control::value() const
+{
+  return value_;
+}
+
+inline serial_port_base::parity::type serial_port_base::parity::value() const
+{
+  return value_;
+}
+
+inline serial_port_base::stop_bits::type
+serial_port_base::stop_bits::value() const
+{
+  return value_;
+}
+
+inline unsigned int serial_port_base::character_size::value() const
+{
+  return value_;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP

test/external/boost/asio/impl/serial_port_base.ipp

@@ -0,0 +1,557 @@
+//
+// impl/serial_port_base.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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)
+//
+
+#ifndef BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
+#define BOOST_ASIO_IMPL_SERIAL_PORT_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_HAS_SERIAL_PORT)
+
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/serial_port_base.hpp>
+
+#if defined(GENERATING_DOCUMENTATION)
+# define BOOST_ASIO_OPTION_STORAGE implementation_defined
+#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# define BOOST_ASIO_OPTION_STORAGE DCB
+#else
+# define BOOST_ASIO_OPTION_STORAGE termios
+#endif
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+boost::system::error_code serial_port_base::baud_rate::store(
+    BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  storage.BaudRate = value_;
+#else
+  speed_t baud;
+  switch (value_)
+  {
+  // Do POSIX-specified rates first.
+  case 0: baud = B0; break;
+  case 50: baud = B50; break;
+  case 75: baud = B75; break;
+  case 110: baud = B110; break;
+  case 134: baud = B134; break;
+  case 150: baud = B150; break;
+  case 200: baud = B200; break;
+  case 300: baud = B300; break;
+  case 600: baud = B600; break;
+  case 1200: baud = B1200; break;
+  case 1800: baud = B1800; break;
+  case 2400: baud = B2400; break;
+  case 4800: baud = B4800; break;
+  case 9600: baud = B9600; break;
+  case 19200: baud = B19200; break;
+  case 38400: baud = B38400; break;
+  // And now the extended ones conditionally.
+# ifdef B7200
+  case 7200: baud = B7200; break;
+# endif
+# ifdef B14400
+  case 14400: baud = B14400; break;
+# endif
+# ifdef B57600
+  case 57600: baud = B57600; break;
+# endif
+# ifdef B115200
+  case 115200: baud = B115200; break;
+# endif
+# ifdef B230400
+  case 230400: baud = B230400; break;
+# endif
+# ifdef B460800
+  case 460800: baud = B460800; break;
+# endif
+# ifdef B500000
+  case 500000: baud = B500000; break;
+# endif
+# ifdef B576000
+  case 576000: baud = B576000; break;
+# endif
+# ifdef B921600
+  case 921600: baud = B921600; break;
+# endif
+# ifdef B1000000
+  case 1000000: baud = B1000000; break;
+# endif
+# ifdef B1152000
+  case 1152000: baud = B1152000; break;
+# endif
+# ifdef B2000000
+  case 2000000: baud = B2000000; break;
+# endif
+# ifdef B3000000
+  case 3000000: baud = B3000000; break;
+# endif
+# ifdef B3500000
+  case 3500000: baud = B3500000; break;
+# endif
+# ifdef B4000000
+  case 4000000: baud = B4000000; break;
+# endif
+  default:
+    baud = B0;
+    ec = boost::asio::error::invalid_argument;
+    return ec;
+  }
+# if defined(_BSD_SOURCE)
+  ::cfsetspeed(&storage, baud);
+# else
+  ::cfsetispeed(&storage, baud);
+  ::cfsetospeed(&storage, baud);
+# endif
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code serial_port_base::baud_rate::load(
+    const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  value_ = storage.BaudRate;
+#else
+  speed_t baud = ::cfgetospeed(&storage);
+  switch (baud)
+  {
+  // First do those specified by POSIX.
+  case B0: value_ = 0; break;
+  case B50: value_ = 50; break;
+  case B75: value_ = 75; break;
+  case B110: value_ = 110; break;
+  case B134: value_ = 134; break;
+  case B150: value_ = 150; break;
+  case B200: value_ = 200; break;
+  case B300: value_ = 300; break;
+  case B600: value_ = 600; break;
+  case B1200: value_ = 1200; break;
+  case B1800: value_ = 1800; break;
+  case B2400: value_ = 2400; break;
+  case B4800: value_ = 4800; break;
+  case B9600: value_ = 9600; break;
+  case B19200: value_ = 19200; break;
+  case B38400: value_ = 38400; break;
+  // Now conditionally handle a bunch of extended rates.
+# ifdef B7200
+  case B7200: value_ = 7200; break;
+# endif
+# ifdef B14400
+  case B14400: value_ = 14400; break;
+# endif
+# ifdef B57600
+  case B57600: value_ = 57600; break;
+# endif
+# ifdef B115200
+  case B115200: value_ = 115200; break;
+# endif
+# ifdef B230400
+  case B230400: value_ = 230400; break;
+# endif
+# ifdef B460800
+  case B460800: value_ = 460800; break;
+# endif
+# ifdef B500000
+  case B500000: value_ = 500000; break;
+# endif
+# ifdef B576000
+  case B576000: value_ = 576000; break;
+# endif
+# ifdef B921600
+  case B921600: value_ = 921600; break;
+# endif
+# ifdef B1000000
+  case B1000000: value_ = 1000000; break;
+# endif
+# ifdef B1152000
+  case B1152000: value_ = 1152000; break;
+# endif
+# ifdef B2000000
+  case B2000000: value_ = 2000000; break;
+# endif
+# ifdef B3000000
+  case B3000000: value_ = 3000000; break;
+# endif
+# ifdef B3500000
+  case B3500000: value_ = 3500000; break;
+# endif
+# ifdef B4000000
+  case B4000000: value_ = 4000000; break;
+# endif
+  default:
+    value_ = 0;
+    ec = boost::asio::error::invalid_argument;
+    return ec;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+serial_port_base::flow_control::flow_control(
+    serial_port_base::flow_control::type t)
+  : value_(t)
+{
+  if (t != none && t != software && t != hardware)
+  {
+    std::out_of_range ex("invalid flow_control value");
+    boost::throw_exception(ex);
+  }
+}
+
+boost::system::error_code serial_port_base::flow_control::store(
+    BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  storage.fOutxCtsFlow = FALSE;
+  storage.fOutxDsrFlow = FALSE;
+  storage.fTXContinueOnXoff = TRUE;
+  storage.fDtrControl = DTR_CONTROL_ENABLE;
+  storage.fDsrSensitivity = FALSE;
+  storage.fOutX = FALSE;
+  storage.fInX = FALSE;
+  storage.fRtsControl = RTS_CONTROL_ENABLE;
+  switch (value_)
+  {
+  case none:
+    break;
+  case software:
+    storage.fOutX = TRUE;
+    storage.fInX = TRUE;
+    break;
+  case hardware:
+    storage.fOutxCtsFlow = TRUE;
+    storage.fRtsControl = RTS_CONTROL_HANDSHAKE;
+    break;
+  default:
+    break;
+  }
+#else
+  switch (value_)
+  {
+  case none:
+    storage.c_iflag &= ~(IXOFF | IXON);
+# if defined(_BSD_SOURCE)
+    storage.c_cflag &= ~CRTSCTS;
+# elif defined(__QNXNTO__)
+    storage.c_cflag &= ~(IHFLOW | OHFLOW);
+# endif
+    break;
+  case software:
+    storage.c_iflag |= IXOFF | IXON;
+# if defined(_BSD_SOURCE)
+    storage.c_cflag &= ~CRTSCTS;
+# elif defined(__QNXNTO__)
+    storage.c_cflag &= ~(IHFLOW | OHFLOW);
+# endif
+    break;
+  case hardware:
+# if defined(_BSD_SOURCE)
+    storage.c_iflag &= ~(IXOFF | IXON);
+    storage.c_cflag |= CRTSCTS;
+    break;
+# elif defined(__QNXNTO__)
+    storage.c_iflag &= ~(IXOFF | IXON);
+    storage.c_cflag |= (IHFLOW | OHFLOW);
+    break;
+# else
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+# endif
+  default:
+    break;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code serial_port_base::flow_control::load(
+    const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  if (storage.fOutX && storage.fInX)
+  {
+    value_ = software;
+  }
+  else if (storage.fOutxCtsFlow && storage.fRtsControl == RTS_CONTROL_HANDSHAKE)
+  {
+    value_ = hardware;
+  }
+  else
+  {
+    value_ = none;
+  }
+#else
+  if (storage.c_iflag & (IXOFF | IXON))
+  {
+    value_ = software;
+  }
+# if defined(_BSD_SOURCE)
+  else if (storage.c_cflag & CRTSCTS)
+  {
+    value_ = hardware;
+  }
+# elif defined(__QNXNTO__)
+  else if (storage.c_cflag & IHFLOW && storage.c_cflag & OHFLOW)
+  {
+    value_ = hardware;
+  }
+# endif
+  else
+  {
+    value_ = none;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+serial_port_base::parity::parity(serial_port_base::parity::type t)
+  : value_(t)
+{
+  if (t != none && t != odd && t != even)
+  {
+    std::out_of_range ex("invalid parity value");
+    boost::throw_exception(ex);
+  }
+}
+
+boost::system::error_code serial_port_base::parity::store(
+    BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  switch (value_)
+  {
+  case none:
+    storage.fParity = FALSE;
+    storage.Parity = NOPARITY;
+    break;
+  case odd:
+    storage.fParity = TRUE;
+    storage.Parity = ODDPARITY;
+    break;
+  case even:
+    storage.fParity = TRUE;
+    storage.Parity = EVENPARITY;
+    break;
+  default:
+    break;
+  }
+#else
+  switch (value_)
+  {
+  case none:
+    storage.c_iflag |= IGNPAR;
+    storage.c_cflag &= ~(PARENB | PARODD);
+    break;
+  case even:
+    storage.c_iflag &= ~(IGNPAR | PARMRK);
+    storage.c_iflag |= INPCK;
+    storage.c_cflag |= PARENB;
+    storage.c_cflag &= ~PARODD;
+    break;
+  case odd:
+    storage.c_iflag &= ~(IGNPAR | PARMRK);
+    storage.c_iflag |= INPCK;
+    storage.c_cflag |= (PARENB | PARODD);
+    break;
+  default:
+    break;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code serial_port_base::parity::load(
+    const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  if (storage.Parity == EVENPARITY)
+  {
+    value_ = even;
+  }
+  else if (storage.Parity == ODDPARITY)
+  {
+    value_ = odd;
+  }
+  else
+  {
+    value_ = none;
+  }
+#else
+  if (storage.c_cflag & PARENB)
+  {
+    if (storage.c_cflag & PARODD)
+    {
+      value_ = odd;
+    }
+    else
+    {
+      value_ = even;
+    }
+  }
+  else
+  {
+    value_ = none;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+serial_port_base::stop_bits::stop_bits(
+    serial_port_base::stop_bits::type t)
+  : value_(t)
+{
+  if (t != one && t != onepointfive && t != two)
+  {
+    std::out_of_range ex("invalid stop_bits value");
+    boost::throw_exception(ex);
+  }
+}
+
+boost::system::error_code serial_port_base::stop_bits::store(
+    BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  switch (value_)
+  {
+  case one:
+    storage.StopBits = ONESTOPBIT;
+    break;
+  case onepointfive:
+    storage.StopBits = ONE5STOPBITS;
+    break;
+  case two:
+    storage.StopBits = TWOSTOPBITS;
+    break;
+  default:
+    break;
+  }
+#else
+  switch (value_)
+  {
+  case one:
+    storage.c_cflag &= ~CSTOPB;
+    break;
+  case two:
+    storage.c_cflag |= CSTOPB;
+    break;
+  default:
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code serial_port_base::stop_bits::load(
+    const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  if (storage.StopBits == ONESTOPBIT)
+  {
+    value_ = one;
+  }
+  else if (storage.StopBits == ONE5STOPBITS)
+  {
+    value_ = onepointfive;
+  }
+  else if (storage.StopBits == TWOSTOPBITS)
+  {
+    value_ = two;
+  }
+  else
+  {
+    value_ = one;
+  }
+#else
+  value_ = (storage.c_cflag & CSTOPB) ? two : one;
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+serial_port_base::character_size::character_size(unsigned int t)
+  : value_(t)
+{
+  if (t < 5 || t > 8)
+  {
+    std::out_of_range ex("invalid character_size value");
+    boost::throw_exception(ex);
+  }
+}
+
+boost::system::error_code serial_port_base::character_size::store(
+    BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  storage.ByteSize = value_;
+#else
+  storage.c_cflag &= ~CSIZE;
+  switch (value_)
+  {
+  case 5: storage.c_cflag |= CS5; break;
+  case 6: storage.c_cflag |= CS6; break;
+  case 7: storage.c_cflag |= CS7; break;
+  case 8: storage.c_cflag |= CS8; break;
+  default: break;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+boost::system::error_code serial_port_base::character_size::load(
+    const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  value_ = storage.ByteSize;
+#else
+  if ((storage.c_cflag & CSIZE) == CS5) { value_ = 5; }
+  else if ((storage.c_cflag & CSIZE) == CS6) { value_ = 6; }
+  else if ((storage.c_cflag & CSIZE) == CS7) { value_ = 7; }
+  else if ((storage.c_cflag & CSIZE) == CS8) { value_ = 8; }
+  else
+  {
+    // Hmmm, use 8 for now.
+    value_ = 8;
+  }
+#endif
+  ec = boost::system::error_code();
+  return ec;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#undef BOOST_ASIO_OPTION_STORAGE
+
+#endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
+
+#endif // BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP

test/external/boost/asio/impl/src.cpp

@@ -0,0 +1,25 @@
+//
+// impl/src.cpp
+// ~~~~~~~~~~~~
+//
+// 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)
+//
+
+#if defined(_MSC_VER) \
+  || defined(__BORLANDC__) \
+  || defined(__DMC__)
+# pragma message ( \
+    "This file is deprecated. " \
+    "Please #include <boost/asio/impl/src.hpp> instead.>)
+#elif defined(__GNUC__) \
+  || defined(__HP_aCC) \
+  || defined(__SUNPRO_CC) \
+  || defined(__IBMCPP__)
+# warning "This file is deprecated."
+# warning "Please #include <boost/asio/impl/src.hpp> instead.>
+#endif
+
+#include <boost/asio/impl/src.hpp>

test/external/boost/asio/impl/src.hpp

@@ -0,0 +1,67 @@
+//
+// impl/src.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_IMPL_SRC_HPP
+#define BOOST_ASIO_IMPL_SRC_HPP
+
+#define BOOST_ASIO_SOURCE
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# error Do not compile Asio library source with BOOST_ASIO_HEADER_ONLY defined
+#endif
+
+#include <boost/asio/impl/error.ipp>
+#include <boost/asio/impl/io_service.ipp>
+#include <boost/asio/impl/serial_port_base.ipp>
+#include <boost/asio/detail/impl/descriptor_ops.ipp>
+#include <boost/asio/detail/impl/dev_poll_reactor.ipp>
+#include <boost/asio/detail/impl/epoll_reactor.ipp>
+#include <boost/asio/detail/impl/eventfd_select_interrupter.ipp>
+#include <boost/asio/detail/impl/handler_tracking.ipp>
+#include <boost/asio/detail/impl/kqueue_reactor.ipp>
+#include <boost/asio/detail/impl/pipe_select_interrupter.ipp>
+#include <boost/asio/detail/impl/posix_event.ipp>
+#include <boost/asio/detail/impl/posix_mutex.ipp>
+#include <boost/asio/detail/impl/posix_thread.ipp>
+#include <boost/asio/detail/impl/posix_tss_ptr.ipp>
+#include <boost/asio/detail/impl/reactive_descriptor_service.ipp>
+#include <boost/asio/detail/impl/reactive_serial_port_service.ipp>
+#include <boost/asio/detail/impl/reactive_socket_service_base.ipp>
+#include <boost/asio/detail/impl/resolver_service_base.ipp>
+#include <boost/asio/detail/impl/select_reactor.ipp>
+#include <boost/asio/detail/impl/service_registry.ipp>
+#include <boost/asio/detail/impl/signal_set_service.ipp>
+#include <boost/asio/detail/impl/socket_ops.ipp>
+#include <boost/asio/detail/impl/socket_select_interrupter.ipp>
+#include <boost/asio/detail/impl/strand_service.ipp>
+#include <boost/asio/detail/impl/task_io_service.ipp>
+#include <boost/asio/detail/impl/throw_error.ipp>
+#include <boost/asio/detail/impl/timer_queue.ipp>
+#include <boost/asio/detail/impl/timer_queue_set.ipp>
+#include <boost/asio/detail/impl/win_iocp_handle_service.ipp>
+#include <boost/asio/detail/impl/win_iocp_io_service.ipp>
+#include <boost/asio/detail/impl/win_iocp_serial_port_service.ipp>
+#include <boost/asio/detail/impl/win_iocp_socket_service_base.ipp>
+#include <boost/asio/detail/impl/win_event.ipp>
+#include <boost/asio/detail/impl/win_mutex.ipp>
+#include <boost/asio/detail/impl/win_static_mutex.ipp>
+#include <boost/asio/detail/impl/win_thread.ipp>
+#include <boost/asio/detail/impl/win_tss_ptr.ipp>
+#include <boost/asio/detail/impl/winsock_init.ipp>
+#include <boost/asio/ip/impl/address.ipp>
+#include <boost/asio/ip/impl/address_v4.ipp>
+#include <boost/asio/ip/impl/address_v6.ipp>
+#include <boost/asio/ip/impl/host_name.ipp>
+#include <boost/asio/ip/detail/impl/endpoint.ipp>
+#include <boost/asio/local/detail/impl/endpoint.ipp>
+
+#endif // BOOST_ASIO_IMPL_SRC_HPP

test/external/boost/asio/impl/write.hpp

@@ -0,0 +1,709 @@
+//
+// impl/write.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_IMPL_WRITE_HPP
+#define BOOST_ASIO_IMPL_WRITE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_completion_cond.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/dependent_type.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename SyncWriteStream, typename ConstBufferSequence,
+    typename CompletionCondition>
+std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  boost::asio::detail::consuming_buffers<
+    const_buffer, ConstBufferSequence> tmp(buffers);
+  std::size_t total_transferred = 0;
+  tmp.prepare(detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred)));
+  while (tmp.begin() != tmp.end())
+  {
+    std::size_t bytes_transferred = s.write_some(tmp, ec);
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    tmp.prepare(detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred)));
+  }
+  return total_transferred;
+}
+
+template <typename SyncWriteStream, typename ConstBufferSequence>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+template <typename SyncWriteStream, typename ConstBufferSequence>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return write(s, buffers, transfer_all(), ec);
+}
+
+template <typename SyncWriteStream, typename ConstBufferSequence,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template <typename SyncWriteStream, typename Allocator,
+    typename CompletionCondition>
+std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
+  b.consume(bytes_transferred);
+  return bytes_transferred;
+}
+
+template <typename SyncWriteStream, typename Allocator>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+template <typename SyncWriteStream, typename Allocator>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return write(s, b, transfer_all(), ec);
+}
+
+template <typename SyncWriteStream, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t write(SyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write(s, b, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "write");
+  return bytes_transferred;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  class write_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+        for (;;)
+        {
+          stream_.async_write_some(buffers_,
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          buffers_.consume(bytes_transferred);
+          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+          if ((!ec && bytes_transferred == 0)
+              || buffers_.begin() == buffers_.end())
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncWriteStream& stream_;
+    boost::asio::detail::consuming_buffers<
+      const_buffer, ConstBufferSequence> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncWriteStream,
+      typename CompletionCondition, typename WriteHandler>
+  class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_op(AsyncWriteStream& stream,
+        const boost::asio::mutable_buffers_1& buffers,
+        CompletionCondition completion_condition,
+        WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          stream_.async_write_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncWriteStream& stream_;
+    boost::asio::mutable_buffer buffer_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncWriteStream,
+      typename CompletionCondition, typename WriteHandler>
+  class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_op(AsyncWriteStream& stream,
+        const boost::asio::const_buffers_1& buffers,
+        CompletionCondition completion_condition,
+        WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          stream_.async_write_some(
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncWriteStream& stream_;
+    boost::asio::const_buffer buffer_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncWriteStream, typename Elem,
+      typename CompletionCondition, typename WriteHandler>
+  class write_op<AsyncWriteStream, boost::array<Elem, 2>,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
+        boost::asio::const_buffer(buffers_[0]),
+        boost::asio::const_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncWriteStream& stream_;
+    boost::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncWriteStream, typename Elem,
+      typename CompletionCondition, typename WriteHandler>
+  class write_op<AsyncWriteStream, std::array<Elem, 2>,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_op(const write_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_op(write_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        stream_(other.stream_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          std::array<boost::asio::const_buffer, 2> >::type bufs = {{
+        boost::asio::const_buffer(buffers_[0]),
+        boost::asio::const_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncWriteStream& stream_;
+    std::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncWriteStream,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncWriteStream,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      write_op<AsyncWriteStream, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncWriteStream, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline write_op<AsyncWriteStream, ConstBufferSequence,
+      CompletionCondition, WriteHandler>
+  make_write_op(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+      CompletionCondition completion_condition, WriteHandler handler)
+  {
+    return write_op<AsyncWriteStream, ConstBufferSequence, CompletionCondition,
+      WriteHandler>(s, buffers, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+  typename CompletionCondition, typename WriteHandler>
+inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_op(
+    s, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncWriteStream, typename ConstBufferSequence,
+    typename WriteHandler>
+inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_op(
+    s, buffers, transfer_all(), BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+      boost::system::error_code(), 0, 1);
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename Allocator, typename WriteHandler>
+  class write_streambuf_handler
+  {
+  public:
+    write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
+        WriteHandler& handler)
+      : streambuf_(streambuf),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_streambuf_handler(const write_streambuf_handler& other)
+      : streambuf_(other.streambuf_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_streambuf_handler(write_streambuf_handler&& other)
+      : streambuf_(other.streambuf_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        const std::size_t bytes_transferred)
+    {
+      streambuf_.consume(bytes_transferred);
+      handler_(ec, bytes_transferred);
+    }
+
+  //private:
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    WriteHandler handler_;
+  };
+
+  template <typename Allocator, typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Allocator, typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Allocator, typename WriteHandler>
+  inline write_streambuf_handler<Allocator, WriteHandler>
+  make_write_streambuf_handler(
+      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+  {
+    return write_streambuf_handler<Allocator, WriteHandler>(b, handler);
+  }
+} // namespace detail
+
+template <typename AsyncWriteStream, typename Allocator,
+    typename CompletionCondition, typename WriteHandler>
+inline void async_write(AsyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write(s, b.data(), completion_condition,
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+}
+
+template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
+inline void async_write(AsyncWriteStream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write(s, b.data(), transfer_all(),
+      detail::make_write_streambuf_handler(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_WRITE_HPP

test/external/boost/asio/impl/write_at.hpp

@@ -0,0 +1,751 @@
+//
+// impl/write_at.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_IMPL_WRITE_AT_HPP
+#define BOOST_ASIO_IMPL_WRITE_AT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_completion_cond.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/dependent_type.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
+    typename CompletionCondition>
+std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  ec = boost::system::error_code();
+  boost::asio::detail::consuming_buffers<
+    const_buffer, ConstBufferSequence> tmp(buffers);
+  std::size_t total_transferred = 0;
+  tmp.prepare(detail::adapt_completion_condition_result(
+        completion_condition(ec, total_transferred)));
+  while (tmp.begin() != tmp.end())
+  {
+    std::size_t bytes_transferred = d.write_some_at(
+        offset + total_transferred, tmp, ec);
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    tmp.prepare(detail::adapt_completion_condition_result(
+          completion_condition(ec, total_transferred)));
+  }
+  return total_transferred;
+}
+
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write_at(
+      d, offset, buffers, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "write_at");
+  return bytes_transferred;
+}
+
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    boost::system::error_code& ec)
+{
+  return write_at(d, offset, buffers, transfer_all(), ec);
+}
+
+template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
+    typename CompletionCondition>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write_at(
+      d, offset, buffers, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "write_at");
+  return bytes_transferred;
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template <typename SyncRandomAccessWriteDevice, typename Allocator,
+    typename CompletionCondition>
+std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition, boost::system::error_code& ec)
+{
+  std::size_t bytes_transferred = write_at(
+      d, offset, b.data(), completion_condition, ec);
+  b.consume(bytes_transferred);
+  return bytes_transferred;
+}
+
+template <typename SyncRandomAccessWriteDevice, typename Allocator>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
+  boost::asio::detail::throw_error(ec, "write_at");
+  return bytes_transferred;
+}
+
+template <typename SyncRandomAccessWriteDevice, typename Allocator>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    boost::system::error_code& ec)
+{
+  return write_at(d, offset, b, transfer_all(), ec);
+}
+
+template <typename SyncRandomAccessWriteDevice, typename Allocator,
+    typename CompletionCondition>
+inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition)
+{
+  boost::system::error_code ec;
+  std::size_t bytes_transferred = write_at(
+      d, offset, b, completion_condition, ec);
+  boost::asio::detail::throw_error(ec, "write_at");
+  return bytes_transferred;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  class write_at_op
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_at_op(AsyncRandomAccessWriteDevice& device,
+        boost::uint64_t offset, const ConstBufferSequence& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      switch (start)
+      {
+        case 1:
+        buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+        for (;;)
+        {
+          device_.async_write_some_at(
+              offset_ + total_transferred_, buffers_,
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          buffers_.consume(bytes_transferred);
+          buffers_.prepare(this->check_for_completion(ec, total_transferred_));
+          if ((!ec && bytes_transferred == 0)
+              || buffers_.begin() == buffers_.end())
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessWriteDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::detail::consuming_buffers<
+      const_buffer, ConstBufferSequence> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessWriteDevice,
+      typename CompletionCondition, typename WriteHandler>
+  class write_at_op<AsyncRandomAccessWriteDevice,
+      boost::asio::mutable_buffers_1, CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_at_op(AsyncRandomAccessWriteDevice& device,
+        boost::uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
+        CompletionCondition completion_condition,
+        WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          device_.async_write_some_at(offset_ + total_transferred_,
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessWriteDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::mutable_buffer buffer_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessWriteDevice,
+      typename CompletionCondition, typename WriteHandler>
+  class write_at_op<AsyncRandomAccessWriteDevice, boost::asio::const_buffers_1,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_at_op(AsyncRandomAccessWriteDevice& device,
+        boost::uint64_t offset, const boost::asio::const_buffers_1& buffers,
+        CompletionCondition completion_condition,
+        WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffer_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffer_(other.buffer_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          device_.async_write_some_at(offset_ + total_transferred_,
+              boost::asio::buffer(buffer_ + total_transferred_, n),
+              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == boost::asio::buffer_size(buffer_))
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessWriteDevice& device_;
+    boost::uint64_t offset_;
+    boost::asio::const_buffer buffer_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+  template <typename AsyncRandomAccessWriteDevice, typename Elem,
+      typename CompletionCondition, typename WriteHandler>
+  class write_at_op<AsyncRandomAccessWriteDevice, boost::array<Elem, 2>,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_at_op(AsyncRandomAccessWriteDevice& device,
+        boost::uint64_t offset, const boost::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
+        boost::asio::const_buffer(buffers_[0]),
+        boost::asio::const_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          device_.async_write_some_at(offset_ + total_transferred_,
+              bufs, BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessWriteDevice& device_;
+    boost::uint64_t offset_;
+    boost::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+#if defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncRandomAccessWriteDevice, typename Elem,
+      typename CompletionCondition, typename WriteHandler>
+  class write_at_op<AsyncRandomAccessWriteDevice, std::array<Elem, 2>,
+      CompletionCondition, WriteHandler>
+    : detail::base_from_completion_cond<CompletionCondition>
+  {
+  public:
+    write_at_op(AsyncRandomAccessWriteDevice& device,
+        boost::uint64_t offset, const std::array<Elem, 2>& buffers,
+        CompletionCondition completion_condition, WriteHandler& handler)
+      : detail::base_from_completion_cond<
+          CompletionCondition>(completion_condition),
+        device_(device),
+        offset_(offset),
+        buffers_(buffers),
+        total_transferred_(0),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_op(const write_at_op& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_op(write_at_op&& other)
+      : detail::base_from_completion_cond<CompletionCondition>(other),
+        device_(other.device_),
+        offset_(other.offset_),
+        buffers_(other.buffers_),
+        total_transferred_(other.total_transferred_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        std::size_t bytes_transferred, int start = 0)
+    {
+      typename boost::asio::detail::dependent_type<Elem,
+          std::array<boost::asio::const_buffer, 2> >::type bufs = {{
+        boost::asio::const_buffer(buffers_[0]),
+        boost::asio::const_buffer(buffers_[1]) }};
+      std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
+      std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
+      std::size_t n = 0;
+      switch (start)
+      {
+        case 1:
+        n = this->check_for_completion(ec, total_transferred_);
+        for (;;)
+        {
+          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
+          bufs[1] = boost::asio::buffer(
+              bufs[1] + (total_transferred_ < buffer_size0
+                ? 0 : total_transferred_ - buffer_size0),
+              n - boost::asio::buffer_size(bufs[0]));
+          device_.async_write_some_at(offset_ + total_transferred_,
+              bufs, BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+          return; default:
+          total_transferred_ += bytes_transferred;
+          if ((!ec && bytes_transferred == 0)
+              || (n = this->check_for_completion(ec, total_transferred_)) == 0
+              || total_transferred_ == buffer_size0 + buffer_size1)
+            break;
+        }
+
+        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
+      }
+    }
+
+  //private:
+    AsyncRandomAccessWriteDevice& device_;
+    boost::uint64_t offset_;
+    std::array<Elem, 2> buffers_;
+    std::size_t total_transferred_;
+    WriteHandler handler_;
+  };
+
+#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
+
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename AsyncRandomAccessWriteDevice,
+      typename ConstBufferSequence, typename CompletionCondition,
+      typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
+        CompletionCondition, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+      typename CompletionCondition, typename WriteHandler>
+  inline write_at_op<AsyncRandomAccessWriteDevice,
+      ConstBufferSequence, CompletionCondition, WriteHandler>
+  make_write_at_op(AsyncRandomAccessWriteDevice& d,
+      boost::uint64_t offset, const ConstBufferSequence& buffers,
+      CompletionCondition completion_condition, WriteHandler handler)
+  {
+    return write_at_op<AsyncRandomAccessWriteDevice,
+      ConstBufferSequence, CompletionCondition, WriteHandler>(
+        d, offset, buffers, completion_condition, handler);
+  }
+} // namespace detail
+
+template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+    typename CompletionCondition, typename WriteHandler>
+inline void async_write_at(AsyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_at_op(
+    d, offset, buffers, completion_condition,
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+    typename WriteHandler>
+inline void async_write_at(AsyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, const ConstBufferSequence& buffers,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  detail::make_write_at_op(
+    d, offset, buffers, transfer_all(),
+      BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))(
+        boost::system::error_code(), 0, 1);
+}
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+namespace detail
+{
+  template <typename Allocator, typename WriteHandler>
+  class write_at_streambuf_op
+  {
+  public:
+    write_at_streambuf_op(
+        boost::asio::basic_streambuf<Allocator>& streambuf,
+        WriteHandler& handler)
+      : streambuf_(streambuf),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+    {
+    }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    write_at_streambuf_op(const write_at_streambuf_op& other)
+      : streambuf_(other.streambuf_),
+        handler_(other.handler_)
+    {
+    }
+
+    write_at_streambuf_op(write_at_streambuf_op&& other)
+      : streambuf_(other.streambuf_),
+        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(other.handler_))
+    {
+    }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    void operator()(const boost::system::error_code& ec,
+        const std::size_t bytes_transferred)
+    {
+      streambuf_.consume(bytes_transferred);
+      handler_(ec, bytes_transferred);
+    }
+
+  //private:
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    WriteHandler handler_;
+  };
+
+  template <typename Allocator, typename WriteHandler>
+  inline void* asio_handler_allocate(std::size_t size,
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, this_handler->handler_);
+  }
+
+  template <typename Allocator, typename WriteHandler>
+  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(Function& function,
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Function, typename Allocator, typename WriteHandler>
+  inline void asio_handler_invoke(const Function& function,
+      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+  {
+    boost_asio_handler_invoke_helpers::invoke(
+        function, this_handler->handler_);
+  }
+
+  template <typename Allocator, typename WriteHandler>
+  inline write_at_streambuf_op<Allocator, WriteHandler>
+  make_write_at_streambuf_op(
+      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
+  {
+    return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
+  }
+} // namespace detail
+
+template <typename AsyncRandomAccessWriteDevice, typename Allocator,
+    typename CompletionCondition, typename WriteHandler>
+inline void async_write_at(AsyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    CompletionCondition completion_condition,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write_at(d, offset, b.data(), completion_condition,
+      detail::make_write_at_streambuf_op(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+}
+
+template <typename AsyncRandomAccessWriteDevice, typename Allocator,
+    typename WriteHandler>
+inline void async_write_at(AsyncRandomAccessWriteDevice& d,
+    boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
+    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+{
+  // If you get an error on the following line it means that your handler does
+  // not meet the documented type requirements for a WriteHandler.
+  BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+  async_write_at(d, offset, b.data(), transfer_all(),
+      detail::make_write_at_streambuf_op(
+        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_WRITE_AT_HPP