[27/56] [abbrv] hadoop git commit: HDFS-8724. Import third_party libraries into the repository. Contributed by Haohui Mai.

[wh...@apache.org]

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_iocp_socket_service_base.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_iocp_socket_service_base.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_iocp_socket_service_base.ipp
new file mode 100644
index 0000000..85d7545
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_iocp_socket_service_base.ipp
@@ -0,0 +1,728 @@
+//
+// detail/impl/win_iocp_socket_service_base.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
+#define ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_IOCP)
+
+#include "asio/detail/win_iocp_socket_service_base.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+win_iocp_socket_service_base::win_iocp_socket_service_base(
+    asio::io_service& io_service)
+  : io_service_(io_service),
+    iocp_service_(use_service<win_iocp_io_service>(io_service)),
+    reactor_(0),
+    connect_ex_(0),
+    mutex_(),
+    impl_list_(0)
+{
+}
+
+void win_iocp_socket_service_base::shutdown_service()
+{
+  // Close all implementations, causing all operations to complete.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  base_implementation_type* impl = impl_list_;
+  while (impl)
+  {
+    asio::error_code ignored_ec;
+    close_for_destruction(*impl);
+    impl = impl->next_;
+  }
+}
+
+void win_iocp_socket_service_base::construct(
+    win_iocp_socket_service_base::base_implementation_type& impl)
+{
+  impl.socket_ = invalid_socket;
+  impl.state_ = 0;
+  impl.cancel_token_.reset();
+#if defined(ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+
+  // Insert implementation into linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void win_iocp_socket_service_base::base_move_construct(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    win_iocp_socket_service_base::base_implementation_type& other_impl)
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.cancel_token_ = other_impl.cancel_token_;
+  other_impl.cancel_token_.reset();
+
+#if defined(ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+
+  // Insert implementation into linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void win_iocp_socket_service_base::base_move_assign(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    win_iocp_socket_service_base& other_service,
+    win_iocp_socket_service_base::base_implementation_type& other_impl)
+{
+  close_for_destruction(impl);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = invalid_socket;
+
+  impl.state_ = other_impl.state_;
+  other_impl.state_ = 0;
+
+  impl.cancel_token_ = other_impl.cancel_token_;
+  other_impl.cancel_token_.reset();
+
+#if defined(ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
+  other_impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
+void win_iocp_socket_service_base::destroy(
+    win_iocp_socket_service_base::base_implementation_type& impl)
+{
+  close_for_destruction(impl);
+
+  // Remove implementation from linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  if (impl_list_ == &impl)
+    impl_list_ = impl.next_;
+  if (impl.prev_)
+    impl.prev_->next_ = impl.next_;
+  if (impl.next_)
+    impl.next_->prev_= impl.prev_;
+  impl.next_ = 0;
+  impl.prev_ = 0;
+}
+
+asio::error_code win_iocp_socket_service_base::close(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+
+    // Check if the reactor was created, in which case we need to close the
+    // socket on the reactor as well to cancel any operations that might be
+    // running there.
+    reactor* r = static_cast<reactor*>(
+          interlocked_compare_exchange_pointer(
+            reinterpret_cast<void**>(&reactor_), 0, 0));
+    if (r)
+      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
+  }
+
+  socket_ops::close(impl.socket_, impl.state_, false, ec);
+
+  impl.socket_ = invalid_socket;
+  impl.state_ = 0;
+  impl.cancel_token_.reset();
+#if defined(ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+
+  return ec;
+}
+
+asio::error_code win_iocp_socket_service_base::cancel(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return ec;
+  }
+
+  ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
+
+  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
+        ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
+  {
+    // The version of Windows supports cancellation from any thread.
+    typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
+    cancel_io_ex_t cancel_io_ex = (cancel_io_ex_t)cancel_io_ex_ptr;
+    socket_type sock = impl.socket_;
+    HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
+    if (!cancel_io_ex(sock_as_handle, 0))
+    {
+      DWORD last_error = ::GetLastError();
+      if (last_error == ERROR_NOT_FOUND)
+      {
+        // ERROR_NOT_FOUND means that there were no operations to be
+        // cancelled. We swallow this error to match the behaviour on other
+        // platforms.
+        ec = asio::error_code();
+      }
+      else
+      {
+        ec = asio::error_code(last_error,
+            asio::error::get_system_category());
+      }
+    }
+    else
+    {
+      ec = asio::error_code();
+    }
+  }
+#if defined(ASIO_ENABLE_CANCELIO)
+  else if (impl.safe_cancellation_thread_id_ == 0)
+  {
+    // No operations have been started, so there's nothing to cancel.
+    ec = asio::error_code();
+  }
+  else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
+  {
+    // Asynchronous operations have been started from the current thread only,
+    // so it is safe to try to cancel them using CancelIo.
+    socket_type sock = impl.socket_;
+    HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
+    if (!::CancelIo(sock_as_handle))
+    {
+      DWORD last_error = ::GetLastError();
+      ec = asio::error_code(last_error,
+          asio::error::get_system_category());
+    }
+    else
+    {
+      ec = asio::error_code();
+    }
+  }
+  else
+  {
+    // Asynchronous operations have been started from more than one thread,
+    // so cancellation is not safe.
+    ec = asio::error::operation_not_supported;
+  }
+#else // defined(ASIO_ENABLE_CANCELIO)
+  else
+  {
+    // Cancellation is not supported as CancelIo may not be used.
+    ec = asio::error::operation_not_supported;
+  }
+#endif // defined(ASIO_ENABLE_CANCELIO)
+
+  // Cancel any operations started via the reactor.
+  if (!ec)
+  {
+    reactor* r = static_cast<reactor*>(
+          interlocked_compare_exchange_pointer(
+            reinterpret_cast<void**>(&reactor_), 0, 0));
+    if (r)
+      r->cancel_ops(impl.socket_, impl.reactor_data_);
+  }
+
+  return ec;
+}
+
+asio::error_code win_iocp_socket_service_base::do_open(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    int family, int type, int protocol, asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = asio::error::already_open;
+    return ec;
+  }
+
+  socket_holder sock(socket_ops::socket(family, type, protocol, ec));
+  if (sock.get() == invalid_socket)
+    return ec;
+
+  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock.get());
+  if (iocp_service_.register_handle(sock_as_handle, ec))
+    return ec;
+
+  impl.socket_ = sock.release();
+  switch (type)
+  {
+  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
+  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
+  default: impl.state_ = 0; break;
+  }
+  impl.cancel_token_.reset(static_cast<void*>(0), socket_ops::noop_deleter());
+  ec = asio::error_code();
+  return ec;
+}
+
+asio::error_code win_iocp_socket_service_base::do_assign(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    int type, socket_type native_socket, asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = asio::error::already_open;
+    return ec;
+  }
+
+  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(native_socket);
+  if (iocp_service_.register_handle(sock_as_handle, ec))
+    return ec;
+
+  impl.socket_ = native_socket;
+  switch (type)
+  {
+  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
+  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
+  default: impl.state_ = 0; break;
+  }
+  impl.cancel_token_.reset(static_cast<void*>(0), socket_ops::noop_deleter());
+  ec = asio::error_code();
+  return ec;
+}
+
+void win_iocp_socket_service_base::start_send_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    WSABUF* buffers, std::size_t buffer_count,
+    socket_base::message_flags flags, bool noop, operation* op)
+{
+  update_cancellation_thread_id(impl);
+  iocp_service_.work_started();
+
+  if (noop)
+    iocp_service_.on_completion(op);
+  else if (!is_open(impl))
+    iocp_service_.on_completion(op, asio::error::bad_descriptor);
+  else
+  {
+    DWORD bytes_transferred = 0;
+    int result = ::WSASend(impl.socket_, buffers,
+        static_cast<DWORD>(buffer_count), &bytes_transferred, flags, op, 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (last_error == ERROR_PORT_UNREACHABLE)
+      last_error = WSAECONNREFUSED;
+    if (result != 0 && last_error != WSA_IO_PENDING)
+      iocp_service_.on_completion(op, last_error, bytes_transferred);
+    else
+      iocp_service_.on_pending(op);
+  }
+}
+
+void win_iocp_socket_service_base::start_send_to_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    WSABUF* buffers, std::size_t buffer_count,
+    const socket_addr_type* addr, int addrlen,
+    socket_base::message_flags flags, operation* op)
+{
+  update_cancellation_thread_id(impl);
+  iocp_service_.work_started();
+
+  if (!is_open(impl))
+    iocp_service_.on_completion(op, asio::error::bad_descriptor);
+  else
+  {
+    DWORD bytes_transferred = 0;
+    int result = ::WSASendTo(impl.socket_, buffers,
+        static_cast<DWORD>(buffer_count),
+        &bytes_transferred, flags, addr, addrlen, op, 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (last_error == ERROR_PORT_UNREACHABLE)
+      last_error = WSAECONNREFUSED;
+    if (result != 0 && last_error != WSA_IO_PENDING)
+      iocp_service_.on_completion(op, last_error, bytes_transferred);
+    else
+      iocp_service_.on_pending(op);
+  }
+}
+
+void win_iocp_socket_service_base::start_receive_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    WSABUF* buffers, std::size_t buffer_count,
+    socket_base::message_flags flags, bool noop, operation* op)
+{
+  update_cancellation_thread_id(impl);
+  iocp_service_.work_started();
+
+  if (noop)
+    iocp_service_.on_completion(op);
+  else if (!is_open(impl))
+    iocp_service_.on_completion(op, asio::error::bad_descriptor);
+  else
+  {
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int result = ::WSARecv(impl.socket_, buffers,
+        static_cast<DWORD>(buffer_count),
+        &bytes_transferred, &recv_flags, op, 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (last_error == ERROR_NETNAME_DELETED)
+      last_error = WSAECONNRESET;
+    else if (last_error == ERROR_PORT_UNREACHABLE)
+      last_error = WSAECONNREFUSED;
+    if (result != 0 && last_error != WSA_IO_PENDING)
+      iocp_service_.on_completion(op, last_error, bytes_transferred);
+    else
+      iocp_service_.on_pending(op);
+  }
+}
+
+void win_iocp_socket_service_base::start_null_buffers_receive_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    socket_base::message_flags flags, reactor_op* op)
+{
+  if ((impl.state_ & socket_ops::stream_oriented) != 0)
+  {
+    // For stream sockets on Windows, we may issue a 0-byte overlapped
+    // WSARecv to wait until there is data available on the socket.
+    ::WSABUF buf = { 0, 0 };
+    start_receive_op(impl, &buf, 1, flags, false, op);
+  }
+  else
+  {
+    start_reactor_op(impl,
+        (flags & socket_base::message_out_of_band)
+          ? reactor::except_op : reactor::read_op,
+        op);
+  }
+}
+
+void win_iocp_socket_service_base::start_receive_from_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    WSABUF* buffers, std::size_t buffer_count, socket_addr_type* addr,
+    socket_base::message_flags flags, int* addrlen, operation* op)
+{
+  update_cancellation_thread_id(impl);
+  iocp_service_.work_started();
+
+  if (!is_open(impl))
+    iocp_service_.on_completion(op, asio::error::bad_descriptor);
+  else
+  {
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int result = ::WSARecvFrom(impl.socket_, buffers,
+        static_cast<DWORD>(buffer_count),
+        &bytes_transferred, &recv_flags, addr, addrlen, op, 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (last_error == ERROR_PORT_UNREACHABLE)
+      last_error = WSAECONNREFUSED;
+    if (result != 0 && last_error != WSA_IO_PENDING)
+      iocp_service_.on_completion(op, last_error, bytes_transferred);
+    else
+      iocp_service_.on_pending(op);
+  }
+}
+
+void win_iocp_socket_service_base::start_accept_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    bool peer_is_open, socket_holder& new_socket, int family, int type,
+    int protocol, void* output_buffer, DWORD address_length, operation* op)
+{
+  update_cancellation_thread_id(impl);
+  iocp_service_.work_started();
+
+  if (!is_open(impl))
+    iocp_service_.on_completion(op, asio::error::bad_descriptor);
+  else if (peer_is_open)
+    iocp_service_.on_completion(op, asio::error::already_open);
+  else
+  {
+    asio::error_code ec;
+    new_socket.reset(socket_ops::socket(family, type, protocol, ec));
+    if (new_socket.get() == invalid_socket)
+      iocp_service_.on_completion(op, ec);
+    else
+    {
+      DWORD bytes_read = 0;
+      BOOL result = ::AcceptEx(impl.socket_, new_socket.get(), output_buffer,
+          0, address_length, address_length, &bytes_read, op);
+      DWORD last_error = ::WSAGetLastError();
+      if (!result && last_error != WSA_IO_PENDING)
+        iocp_service_.on_completion(op, last_error);
+      else
+        iocp_service_.on_pending(op);
+    }
+  }
+}
+
+void win_iocp_socket_service_base::restart_accept_op(
+    socket_type s, socket_holder& new_socket, int family, int type,
+    int protocol, void* output_buffer, DWORD address_length, operation* op)
+{
+  new_socket.reset();
+  iocp_service_.work_started();
+
+  asio::error_code ec;
+  new_socket.reset(socket_ops::socket(family, type, protocol, ec));
+  if (new_socket.get() == invalid_socket)
+    iocp_service_.on_completion(op, ec);
+  else
+  {
+    DWORD bytes_read = 0;
+    BOOL result = ::AcceptEx(s, new_socket.get(), output_buffer,
+        0, address_length, address_length, &bytes_read, op);
+    DWORD last_error = ::WSAGetLastError();
+    if (!result && last_error != WSA_IO_PENDING)
+      iocp_service_.on_completion(op, last_error);
+    else
+      iocp_service_.on_pending(op);
+  }
+}
+
+void win_iocp_socket_service_base::start_reactor_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    int op_type, reactor_op* op)
+{
+  reactor& r = get_reactor();
+  update_cancellation_thread_id(impl);
+
+  if (is_open(impl))
+  {
+    r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false, false);
+    return;
+  }
+  else
+    op->ec_ = asio::error::bad_descriptor;
+
+  iocp_service_.post_immediate_completion(op, false);
+}
+
+void win_iocp_socket_service_base::start_connect_op(
+    win_iocp_socket_service_base::base_implementation_type& impl,
+    int family, int type, const socket_addr_type* addr,
+    std::size_t addrlen, win_iocp_socket_connect_op_base* op)
+{
+  // If ConnectEx is available, use that.
+  if (family == ASIO_OS_DEF(AF_INET)
+      || family == ASIO_OS_DEF(AF_INET6))
+  {
+    if (connect_ex_fn connect_ex = get_connect_ex(impl, type))
+    {
+      union address_union
+      {
+        socket_addr_type base;
+        sockaddr_in4_type v4;
+        sockaddr_in6_type v6;
+      } a;
+
+      using namespace std; // For memset.
+      memset(&a, 0, sizeof(a));
+      a.base.sa_family = family;
+
+      socket_ops::bind(impl.socket_, &a.base,
+          family == ASIO_OS_DEF(AF_INET)
+          ? sizeof(a.v4) : sizeof(a.v6), op->ec_);
+      if (op->ec_ && op->ec_ != asio::error::invalid_argument)
+      {
+        iocp_service_.post_immediate_completion(op, false);
+        return;
+      }
+
+      op->connect_ex_ = true;
+      update_cancellation_thread_id(impl);
+      iocp_service_.work_started();
+
+      BOOL result = connect_ex(impl.socket_,
+          addr, static_cast<int>(addrlen), 0, 0, 0, op);
+      DWORD last_error = ::WSAGetLastError();
+      if (!result && last_error != WSA_IO_PENDING)
+        iocp_service_.on_completion(op, last_error);
+      else
+        iocp_service_.on_pending(op);
+      return;
+    }
+  }
+
+  // Otherwise, fall back to a reactor-based implementation.
+  reactor& r = get_reactor();
+  update_cancellation_thread_id(impl);
+
+  if ((impl.state_ & socket_ops::non_blocking) != 0
+      || socket_ops::set_internal_non_blocking(
+        impl.socket_, impl.state_, true, op->ec_))
+  {
+    if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
+    {
+      if (op->ec_ == asio::error::in_progress
+          || op->ec_ == asio::error::would_block)
+      {
+        op->ec_ = asio::error_code();
+        r.start_op(reactor::connect_op, impl.socket_,
+            impl.reactor_data_, op, false, false);
+        return;
+      }
+    }
+  }
+
+  r.post_immediate_completion(op, false);
+}
+
+void win_iocp_socket_service_base::close_for_destruction(
+    win_iocp_socket_service_base::base_implementation_type& impl)
+{
+  if (is_open(impl))
+  {
+    ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+
+    // Check if the reactor was created, in which case we need to close the
+    // socket on the reactor as well to cancel any operations that might be
+    // running there.
+    reactor* r = static_cast<reactor*>(
+          interlocked_compare_exchange_pointer(
+            reinterpret_cast<void**>(&reactor_), 0, 0));
+    if (r)
+      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
+  }
+
+  asio::error_code ignored_ec;
+  socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
+  impl.socket_ = invalid_socket;
+  impl.state_ = 0;
+  impl.cancel_token_.reset();
+#if defined(ASIO_ENABLE_CANCELIO)
+  impl.safe_cancellation_thread_id_ = 0;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+}
+
+void win_iocp_socket_service_base::update_cancellation_thread_id(
+    win_iocp_socket_service_base::base_implementation_type& impl)
+{
+#if defined(ASIO_ENABLE_CANCELIO)
+  if (impl.safe_cancellation_thread_id_ == 0)
+    impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
+  else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
+    impl.safe_cancellation_thread_id_ = ~DWORD(0);
+#else // defined(ASIO_ENABLE_CANCELIO)
+  (void)impl;
+#endif // defined(ASIO_ENABLE_CANCELIO)
+}
+
+reactor& win_iocp_socket_service_base::get_reactor()
+{
+  reactor* r = static_cast<reactor*>(
+        interlocked_compare_exchange_pointer(
+          reinterpret_cast<void**>(&reactor_), 0, 0));
+  if (!r)
+  {
+    r = &(use_service<reactor>(io_service_));
+    interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r);
+  }
+  return *r;
+}
+
+win_iocp_socket_service_base::connect_ex_fn
+win_iocp_socket_service_base::get_connect_ex(
+    win_iocp_socket_service_base::base_implementation_type& impl, int type)
+{
+  if (type != ASIO_OS_DEF(SOCK_STREAM)
+      && type != ASIO_OS_DEF(SOCK_SEQPACKET))
+    return 0;
+
+  void* ptr = interlocked_compare_exchange_pointer(&connect_ex_, 0, 0);
+  if (!ptr)
+  {
+    GUID guid = { 0x25a207b9, 0xddf3, 0x4660,
+      { 0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e } };
+
+    DWORD bytes = 0;
+    if (::WSAIoctl(impl.socket_, SIO_GET_EXTENSION_FUNCTION_POINTER,
+          &guid, sizeof(guid), &ptr, sizeof(ptr), &bytes, 0, 0) != 0)
+    {
+      // Set connect_ex_ to a special value to indicate that ConnectEx is
+      // unavailable. That way we won't bother trying to look it up again.
+      ptr = this;
+    }
+
+    interlocked_exchange_pointer(&connect_ex_, ptr);
+  }
+
+  return reinterpret_cast<connect_ex_fn>(ptr == this ? 0 : ptr);
+}
+
+void* win_iocp_socket_service_base::interlocked_compare_exchange_pointer(
+    void** dest, void* exch, void* cmp)
+{
+#if defined(_M_IX86)
+  return reinterpret_cast<void*>(InterlockedCompareExchange(
+        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch),
+        reinterpret_cast<LONG>(cmp)));
+#else
+  return InterlockedCompareExchangePointer(dest, exch, cmp);
+#endif
+}
+
+void* win_iocp_socket_service_base::interlocked_exchange_pointer(
+    void** dest, void* val)
+{
+#if defined(_M_IX86)
+  return reinterpret_cast<void*>(InterlockedExchange(
+        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(val)));
+#else
+  return InterlockedExchangePointer(dest, val);
+#endif
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_IOCP)
+
+#endif // ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_mutex.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_mutex.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_mutex.ipp
new file mode 100644
index 0000000..18ce17d
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_mutex.ipp
@@ -0,0 +1,78 @@
+//
+// detail/impl/win_mutex.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
+#define ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS)
+
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_mutex.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+win_mutex::win_mutex()
+{
+  int error = do_init();
+  asio::error_code ec(error,
+      asio::error::get_system_category());
+  asio::detail::throw_error(ec, "mutex");
+}
+
+int win_mutex::do_init()
+{
+#if defined(__MINGW32__)
+  // Not sure if MinGW supports structured exception handling, so for now
+  // we'll just call the Windows API and hope.
+# if defined(UNDER_CE)
+  ::InitializeCriticalSection(&crit_section_);
+# else
+  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+    return ::GetLastError();
+# endif
+  return 0;
+#else
+  __try
+  {
+# if defined(UNDER_CE)
+    ::InitializeCriticalSection(&crit_section_);
+# else
+    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+      return ::GetLastError();
+# endif
+  }
+  __except(GetExceptionCode() == STATUS_NO_MEMORY
+      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+  {
+    return ERROR_OUTOFMEMORY;
+  }
+
+  return 0;
+#endif
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS)
+
+#endif // ASIO_DETAIL_IMPL_WIN_MUTEX_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_object_handle_service.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_object_handle_service.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_object_handle_service.ipp
new file mode 100644
index 0000000..7a7d430
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_object_handle_service.ipp
@@ -0,0 +1,444 @@
+//
+// detail/impl/win_object_handle_service.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
+#define ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
+
+#include "asio/detail/win_object_handle_service.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+win_object_handle_service::win_object_handle_service(
+    asio::io_service& io_service)
+  : io_service_(asio::use_service<io_service_impl>(io_service)),
+    mutex_(),
+    impl_list_(0),
+    shutdown_(false)
+{
+}
+
+void win_object_handle_service::shutdown_service()
+{
+  mutex::scoped_lock lock(mutex_);
+
+  // Setting this flag to true prevents new objects from being registered, and
+  // new asynchronous wait operations from being started. We only need to worry
+  // about cleaning up the operations that are currently in progress.
+  shutdown_ = true;
+
+  op_queue<operation> ops;
+  for (implementation_type* impl = impl_list_; impl; impl = impl->next_)
+    ops.push(impl->op_queue_);
+
+  lock.unlock();
+
+  io_service_.abandon_operations(ops);
+}
+
+void win_object_handle_service::construct(
+    win_object_handle_service::implementation_type& impl)
+{
+  impl.handle_ = INVALID_HANDLE_VALUE;
+  impl.wait_handle_ = INVALID_HANDLE_VALUE;
+  impl.owner_ = this;
+
+  // Insert implementation into linked list of all implementations.
+  mutex::scoped_lock lock(mutex_);
+  if (!shutdown_)
+  {
+    impl.next_ = impl_list_;
+    impl.prev_ = 0;
+    if (impl_list_)
+      impl_list_->prev_ = &impl;
+    impl_list_ = &impl;
+  }
+}
+
+void win_object_handle_service::move_construct(
+    win_object_handle_service::implementation_type& impl,
+    win_object_handle_service::implementation_type& other_impl)
+{
+  mutex::scoped_lock lock(mutex_);
+
+  // Insert implementation into linked list of all implementations.
+  if (!shutdown_)
+  {
+    impl.next_ = impl_list_;
+    impl.prev_ = 0;
+    if (impl_list_)
+      impl_list_->prev_ = &impl;
+    impl_list_ = &impl;
+  }
+
+  impl.handle_ = other_impl.handle_;
+  other_impl.handle_ = INVALID_HANDLE_VALUE;
+  impl.wait_handle_ = other_impl.wait_handle_;
+  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
+  impl.op_queue_.push(other_impl.op_queue_);
+  impl.owner_ = this;
+
+  // We must not hold the lock while calling UnregisterWaitEx. This is because
+  // the registered callback function might be invoked while we are waiting for
+  // UnregisterWaitEx to complete.
+  lock.unlock();
+
+  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
+    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
+
+  if (!impl.op_queue_.empty())
+    register_wait_callback(impl, lock);
+}
+
+void win_object_handle_service::move_assign(
+    win_object_handle_service::implementation_type& impl,
+    win_object_handle_service& other_service,
+    win_object_handle_service::implementation_type& other_impl)
+{
+  asio::error_code ignored_ec;
+  close(impl, ignored_ec);
+
+  mutex::scoped_lock lock(mutex_);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.handle_ = other_impl.handle_;
+  other_impl.handle_ = INVALID_HANDLE_VALUE;
+  impl.wait_handle_ = other_impl.wait_handle_;
+  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
+  impl.op_queue_.push(other_impl.op_queue_);
+  impl.owner_ = this;
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+
+  // We must not hold the lock while calling UnregisterWaitEx. This is because
+  // the registered callback function might be invoked while we are waiting for
+  // UnregisterWaitEx to complete.
+  lock.unlock();
+
+  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
+    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
+
+  if (!impl.op_queue_.empty())
+    register_wait_callback(impl, lock);
+}
+
+void win_object_handle_service::destroy(
+    win_object_handle_service::implementation_type& impl)
+{
+  mutex::scoped_lock lock(mutex_);
+
+  // Remove implementation from linked list of all implementations.
+  if (impl_list_ == &impl)
+    impl_list_ = impl.next_;
+  if (impl.prev_)
+    impl.prev_->next_ = impl.next_;
+  if (impl.next_)
+    impl.next_->prev_= impl.prev_;
+  impl.next_ = 0;
+  impl.prev_ = 0;
+
+  if (is_open(impl))
+  {
+    ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
+
+    HANDLE wait_handle = impl.wait_handle_;
+    impl.wait_handle_ = INVALID_HANDLE_VALUE;
+
+    op_queue<operation> ops;
+    while (wait_op* op = impl.op_queue_.front())
+    {
+      op->ec_ = asio::error::operation_aborted;
+      impl.op_queue_.pop();
+      ops.push(op);
+    }
+
+    // We must not hold the lock while calling UnregisterWaitEx. This is
+    // because the registered callback function might be invoked while we are
+    // waiting for UnregisterWaitEx to complete.
+    lock.unlock();
+
+    if (wait_handle != INVALID_HANDLE_VALUE)
+      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
+
+    ::CloseHandle(impl.handle_);
+    impl.handle_ = INVALID_HANDLE_VALUE;
+
+    io_service_.post_deferred_completions(ops);
+  }
+}
+
+asio::error_code win_object_handle_service::assign(
+    win_object_handle_service::implementation_type& impl,
+    const native_handle_type& handle, asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ec = asio::error::already_open;
+    return ec;
+  }
+
+  impl.handle_ = handle;
+  ec = asio::error_code();
+  return ec;
+}
+
+asio::error_code win_object_handle_service::close(
+    win_object_handle_service::implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
+
+    mutex::scoped_lock lock(mutex_);
+
+    HANDLE wait_handle = impl.wait_handle_;
+    impl.wait_handle_ = INVALID_HANDLE_VALUE;
+
+    op_queue<operation> completed_ops;
+    while (wait_op* op = impl.op_queue_.front())
+    {
+      impl.op_queue_.pop();
+      op->ec_ = asio::error::operation_aborted;
+      completed_ops.push(op);
+    }
+
+    // We must not hold the lock while calling UnregisterWaitEx. This is
+    // because the registered callback function might be invoked while we are
+    // waiting for UnregisterWaitEx to complete.
+    lock.unlock();
+
+    if (wait_handle != INVALID_HANDLE_VALUE)
+      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
+
+    if (::CloseHandle(impl.handle_))
+    {
+      impl.handle_ = INVALID_HANDLE_VALUE;
+      ec = asio::error_code();
+    }
+    else
+    {
+      DWORD last_error = ::GetLastError();
+      ec = asio::error_code(last_error,
+          asio::error::get_system_category());
+    }
+
+    io_service_.post_deferred_completions(completed_ops);
+  }
+  else
+  {
+    ec = asio::error_code();
+  }
+
+  return ec;
+}
+
+asio::error_code win_object_handle_service::cancel(
+    win_object_handle_service::implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (is_open(impl))
+  {
+    ASIO_HANDLER_OPERATION(("object_handle", &impl, "cancel"));
+
+    mutex::scoped_lock lock(mutex_);
+
+    HANDLE wait_handle = impl.wait_handle_;
+    impl.wait_handle_ = INVALID_HANDLE_VALUE;
+
+    op_queue<operation> completed_ops;
+    while (wait_op* op = impl.op_queue_.front())
+    {
+      op->ec_ = asio::error::operation_aborted;
+      impl.op_queue_.pop();
+      completed_ops.push(op);
+    }
+
+    // We must not hold the lock while calling UnregisterWaitEx. This is
+    // because the registered callback function might be invoked while we are
+    // waiting for UnregisterWaitEx to complete.
+    lock.unlock();
+
+    if (wait_handle != INVALID_HANDLE_VALUE)
+      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
+
+    ec = asio::error_code();
+
+    io_service_.post_deferred_completions(completed_ops);
+  }
+  else
+  {
+    ec = asio::error::bad_descriptor;
+  }
+
+  return ec;
+}
+
+void win_object_handle_service::wait(
+    win_object_handle_service::implementation_type& impl,
+    asio::error_code& ec)
+{
+  switch (::WaitForSingleObject(impl.handle_, INFINITE))
+  {
+  case WAIT_FAILED:
+    {
+      DWORD last_error = ::GetLastError();
+      ec = asio::error_code(last_error,
+          asio::error::get_system_category());
+      break;
+    }
+  case WAIT_OBJECT_0:
+  case WAIT_ABANDONED:
+  default:
+    ec = asio::error_code();
+    break;
+  }
+}
+
+void win_object_handle_service::start_wait_op(
+    win_object_handle_service::implementation_type& impl, wait_op* op)
+{
+  io_service_.work_started();
+
+  if (is_open(impl))
+  {
+    mutex::scoped_lock lock(mutex_);
+
+    if (!shutdown_)
+    {
+      impl.op_queue_.push(op);
+
+      // Only the first operation to be queued gets to register a wait callback.
+      // Subsequent operations have to wait for the first to finish.
+      if (impl.op_queue_.front() == op)
+        register_wait_callback(impl, lock);
+    }
+    else
+    {
+      lock.unlock();
+      io_service_.post_deferred_completion(op);
+    }
+  }
+  else
+  {
+    op->ec_ = asio::error::bad_descriptor;
+    io_service_.post_deferred_completion(op);
+  }
+}
+
+void win_object_handle_service::register_wait_callback(
+    win_object_handle_service::implementation_type& impl,
+    mutex::scoped_lock& lock)
+{
+  lock.lock();
+
+  if (!RegisterWaitForSingleObject(&impl.wait_handle_,
+        impl.handle_, &win_object_handle_service::wait_callback,
+        &impl, INFINITE, WT_EXECUTEONLYONCE))
+  {
+    DWORD last_error = ::GetLastError();
+    asio::error_code ec(last_error,
+        asio::error::get_system_category());
+
+    op_queue<operation> completed_ops;
+    while (wait_op* op = impl.op_queue_.front())
+    {
+      op->ec_ = ec;
+      impl.op_queue_.pop();
+      completed_ops.push(op);
+    }
+
+    lock.unlock();
+    io_service_.post_deferred_completions(completed_ops);
+  }
+}
+
+void win_object_handle_service::wait_callback(PVOID param, BOOLEAN)
+{
+  implementation_type* impl = static_cast<implementation_type*>(param);
+  mutex::scoped_lock lock(impl->owner_->mutex_);
+
+  if (impl->wait_handle_ != INVALID_HANDLE_VALUE)
+  {
+    ::UnregisterWaitEx(impl->wait_handle_, NULL);
+    impl->wait_handle_ = INVALID_HANDLE_VALUE;
+  }
+
+  if (wait_op* op = impl->op_queue_.front())
+  {
+    op_queue<operation> completed_ops;
+
+    op->ec_ = asio::error_code();
+    impl->op_queue_.pop();
+    completed_ops.push(op);
+
+    if (!impl->op_queue_.empty())
+    {
+      if (!RegisterWaitForSingleObject(&impl->wait_handle_,
+            impl->handle_, &win_object_handle_service::wait_callback,
+            param, INFINITE, WT_EXECUTEONLYONCE))
+      {
+        DWORD last_error = ::GetLastError();
+        asio::error_code ec(last_error,
+            asio::error::get_system_category());
+
+        while (wait_op* op = impl->op_queue_.front())
+        {
+          op->ec_ = ec;
+          impl->op_queue_.pop();
+          completed_ops.push(op);
+        }
+      }
+    }
+
+    lock.unlock();
+    impl->owner_->io_service_.post_deferred_completions(completed_ops);
+  }
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
+
+#endif // ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_static_mutex.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_static_mutex.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_static_mutex.ipp
new file mode 100644
index 0000000..366d7cf
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_static_mutex.ipp
@@ -0,0 +1,118 @@
+//
+// detail/impl/win_static_mutex.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
+#define ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS)
+
+#include <cstdio>
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_static_mutex.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+void win_static_mutex::init()
+{
+  int error = do_init();
+  asio::error_code ec(error,
+      asio::error::get_system_category());
+  asio::detail::throw_error(ec, "static_mutex");
+}
+
+int win_static_mutex::do_init()
+{
+  using namespace std; // For sprintf.
+  wchar_t mutex_name[128];
+#if defined(ASIO_HAS_SECURE_RTL)
+  swprintf_s(
+#else // defined(ASIO_HAS_SECURE_RTL)
+  _snwprintf(
+#endif // defined(ASIO_HAS_SECURE_RTL)
+      mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
+      static_cast<unsigned int>(::GetCurrentProcessId()), this);
+
+  HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
+  DWORD last_error = ::GetLastError();
+  if (mutex == 0)
+    return ::GetLastError();
+
+  if (last_error == ERROR_ALREADY_EXISTS)
+    ::WaitForSingleObject(mutex, INFINITE);
+
+  if (initialised_)
+  {
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return 0;
+  }
+
+#if defined(__MINGW32__)
+  // Not sure if MinGW supports structured exception handling, so for now
+  // we'll just call the Windows API and hope.
+# if defined(UNDER_CE)
+  ::InitializeCriticalSection(&crit_section_);
+# else
+  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+  {
+    last_error = ::GetLastError();
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return last_error;
+  }
+# endif
+#else
+  __try
+  {
+# if defined(UNDER_CE)
+    ::InitializeCriticalSection(&crit_section_);
+# else
+    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
+    {
+      last_error = ::GetLastError();
+      ::ReleaseMutex(mutex);
+      ::CloseHandle(mutex);
+      return last_error;
+    }
+# endif
+  }
+  __except(GetExceptionCode() == STATUS_NO_MEMORY
+      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+  {
+    ::ReleaseMutex(mutex);
+    ::CloseHandle(mutex);
+    return ERROR_OUTOFMEMORY;
+  }
+#endif
+
+  initialised_ = true;
+  ::ReleaseMutex(mutex);
+  ::CloseHandle(mutex);
+  return 0;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS)
+
+#endif // ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_thread.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_thread.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_thread.ipp
new file mode 100644
index 0000000..554f9f6
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_thread.ipp
@@ -0,0 +1,139 @@
+//
+// detail/impl/win_thread.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_THREAD_IPP
+#define ASIO_DETAIL_IMPL_WIN_THREAD_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+
+#include <process.h>
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_thread.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+win_thread::~win_thread()
+{
+  ::CloseHandle(thread_);
+
+  // The exit_event_ handle is deliberately allowed to leak here since it
+  // is an error for the owner of an internal thread not to join() it.
+}
+
+void win_thread::join()
+{
+  HANDLE handles[2] = { exit_event_, thread_ };
+  ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
+  ::CloseHandle(exit_event_);
+  if (terminate_threads())
+  {
+    ::TerminateThread(thread_, 0);
+  }
+  else
+  {
+    ::QueueUserAPC(apc_function, thread_, 0);
+    ::WaitForSingleObject(thread_, INFINITE);
+  }
+}
+
+void win_thread::start_thread(func_base* arg, unsigned int stack_size)
+{
+  ::HANDLE entry_event = 0;
+  arg->entry_event_ = entry_event = ::CreateEvent(0, true, false, 0);
+  if (!entry_event)
+  {
+    DWORD last_error = ::GetLastError();
+    delete arg;
+    asio::error_code ec(last_error,
+        asio::error::get_system_category());
+    asio::detail::throw_error(ec, "thread.entry_event");
+  }
+
+  arg->exit_event_ = exit_event_ = ::CreateEvent(0, true, false, 0);
+  if (!exit_event_)
+  {
+    DWORD last_error = ::GetLastError();
+    delete arg;
+    asio::error_code ec(last_error,
+        asio::error::get_system_category());
+    asio::detail::throw_error(ec, "thread.exit_event");
+  }
+
+  unsigned int thread_id = 0;
+  thread_ = reinterpret_cast<HANDLE>(::_beginthreadex(0,
+        stack_size, win_thread_function, arg, 0, &thread_id));
+  if (!thread_)
+  {
+    DWORD last_error = ::GetLastError();
+    delete arg;
+    if (entry_event)
+      ::CloseHandle(entry_event);
+    if (exit_event_)
+      ::CloseHandle(exit_event_);
+    asio::error_code ec(last_error,
+        asio::error::get_system_category());
+    asio::detail::throw_error(ec, "thread");
+  }
+
+  if (entry_event)
+  {
+    ::WaitForSingleObject(entry_event, INFINITE);
+    ::CloseHandle(entry_event);
+  }
+}
+
+unsigned int __stdcall win_thread_function(void* arg)
+{
+  win_thread::auto_func_base_ptr func = {
+      static_cast<win_thread::func_base*>(arg) };
+
+  ::SetEvent(func.ptr->entry_event_);
+
+  func.ptr->run();
+
+  // Signal that the thread has finished its work, but rather than returning go
+  // to sleep to put the thread into a well known state. If the thread is being
+  // joined during global object destruction then it may be killed using
+  // TerminateThread (to avoid a deadlock in DllMain). Otherwise, the SleepEx
+  // call will be interrupted using QueueUserAPC and the thread will shut down
+  // cleanly.
+  HANDLE exit_event = func.ptr->exit_event_;
+  delete func.ptr;
+  func.ptr = 0;
+  ::SetEvent(exit_event);
+  ::SleepEx(INFINITE, TRUE);
+
+  return 0;
+}
+
+#if defined(WINVER) && (WINVER < 0x0500)
+void __stdcall apc_function(ULONG) {}
+#else
+void __stdcall apc_function(ULONG_PTR) {}
+#endif
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS) && !defined(UNDER_CE)
+
+#endif // ASIO_DETAIL_IMPL_WIN_THREAD_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_tss_ptr.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_tss_ptr.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_tss_ptr.ipp
new file mode 100644
index 0000000..7fa4c26
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/win_tss_ptr.ipp
@@ -0,0 +1,57 @@
+//
+// detail/impl/win_tss_ptr.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
+#define ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS)
+
+#include "asio/detail/throw_error.hpp"
+#include "asio/detail/win_tss_ptr.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+DWORD win_tss_ptr_create()
+{
+#if defined(UNDER_CE)
+  enum { out_of_indexes = 0xFFFFFFFF };
+#else
+  enum { out_of_indexes = TLS_OUT_OF_INDEXES };
+#endif
+
+  DWORD tss_key = ::TlsAlloc();
+  if (tss_key == out_of_indexes)
+  {
+    DWORD last_error = ::GetLastError();
+    asio::error_code ec(last_error,
+        asio::error::get_system_category());
+    asio::detail::throw_error(ec, "tss");
+  }
+  return tss_key;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS)
+
+#endif // ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_ssocket_service_base.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_ssocket_service_base.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_ssocket_service_base.ipp
new file mode 100644
index 0000000..c5aa3f4
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_ssocket_service_base.ipp
@@ -0,0 +1,612 @@
+//
+// detail/impl/winrt_ssocket_service_base.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
+#define ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+
+#include <cstring>
+#include "asio/detail/winrt_ssocket_service_base.hpp"
+#include "asio/detail/winrt_async_op.hpp"
+#include "asio/detail/winrt_utils.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+winrt_ssocket_service_base::winrt_ssocket_service_base(
+    asio::io_service& io_service)
+  : io_service_(use_service<io_service_impl>(io_service)),
+    async_manager_(use_service<winrt_async_manager>(io_service)),
+    mutex_(),
+    impl_list_(0)
+{
+}
+
+void winrt_ssocket_service_base::shutdown_service()
+{
+  // Close all implementations, causing all operations to complete.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  base_implementation_type* impl = impl_list_;
+  while (impl)
+  {
+    asio::error_code ignored_ec;
+    close(*impl, ignored_ec);
+    impl = impl->next_;
+  }
+}
+
+void winrt_ssocket_service_base::construct(
+    winrt_ssocket_service_base::base_implementation_type& impl)
+{
+  // Insert implementation into linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void winrt_ssocket_service_base::base_move_construct(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    winrt_ssocket_service_base::base_implementation_type& other_impl)
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = nullptr;
+
+  // Insert implementation into linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void winrt_ssocket_service_base::base_move_assign(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    winrt_ssocket_service_base& other_service,
+    winrt_ssocket_service_base::base_implementation_type& other_impl)
+{
+  asio::error_code ignored_ec;
+  close(impl, ignored_ec);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = nullptr;
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
+void winrt_ssocket_service_base::destroy(
+    winrt_ssocket_service_base::base_implementation_type& impl)
+{
+  asio::error_code ignored_ec;
+  close(impl, ignored_ec);
+
+  // Remove implementation from linked list of all implementations.
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  if (impl_list_ == &impl)
+    impl_list_ = impl.next_;
+  if (impl.prev_)
+    impl.prev_->next_ = impl.next_;
+  if (impl.next_)
+    impl.next_->prev_= impl.prev_;
+  impl.next_ = 0;
+  impl.prev_ = 0;
+}
+
+asio::error_code winrt_ssocket_service_base::close(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    asio::error_code& ec)
+{
+  if (impl.socket_)
+  {
+    delete impl.socket_;
+    impl.socket_ = nullptr;
+  }
+
+  ec = asio::error_code();
+  return ec;
+}
+
+std::size_t winrt_ssocket_service_base::do_get_endpoint(
+    const base_implementation_type& impl, bool local,
+    void* addr, std::size_t addr_len, asio::error_code& ec) const
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return addr_len;
+  }
+
+  try
+  {
+    std::string addr_string = winrt_utils::string(local
+        ? impl.socket_->Information->LocalAddress->CanonicalName
+        : impl.socket_->Information->RemoteAddress->CanonicalName);
+    unsigned short port = winrt_utils::integer(local
+        ? impl.socket_->Information->LocalPort
+        : impl.socket_->Information->RemotePort);
+    unsigned long scope = 0;
+
+    switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+    {
+    case ASIO_OS_DEF(AF_INET):
+      if (addr_len < sizeof(sockaddr_in4_type))
+      {
+        ec = asio::error::invalid_argument;
+        return addr_len;
+      }
+      else
+      {
+        socket_ops::inet_pton(ASIO_OS_DEF(AF_INET), addr_string.c_str(),
+            &reinterpret_cast<sockaddr_in4_type*>(addr)->sin_addr, &scope, ec);
+        reinterpret_cast<sockaddr_in4_type*>(addr)->sin_port
+          = socket_ops::host_to_network_short(port);
+        ec = asio::error_code();
+        return sizeof(sockaddr_in4_type);
+      }
+    case ASIO_OS_DEF(AF_INET6):
+      if (addr_len < sizeof(sockaddr_in6_type))
+      {
+        ec = asio::error::invalid_argument;
+        return addr_len;
+      }
+      else
+      {
+        socket_ops::inet_pton(ASIO_OS_DEF(AF_INET6), addr_string.c_str(),
+            &reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_addr, &scope, ec);
+        reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_port
+          = socket_ops::host_to_network_short(port);
+        ec = asio::error_code();
+        return sizeof(sockaddr_in6_type);
+      }
+    default:
+      ec = asio::error::address_family_not_supported;
+      return addr_len;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+    return addr_len;
+  }
+}
+
+asio::error_code winrt_ssocket_service_base::do_set_option(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    int level, int optname, const void* optval,
+    std::size_t optlen, asio::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return ec;
+  }
+
+  try
+  {
+    if (level == ASIO_OS_DEF(SOL_SOCKET)
+        && optname == ASIO_OS_DEF(SO_KEEPALIVE))
+    {
+      if (optlen == sizeof(int))
+      {
+        int value = 0;
+        std::memcpy(&value, optval, optlen);
+        impl.socket_->Control->KeepAlive = !!value;
+        ec = asio::error_code();
+      }
+      else
+      {
+        ec = asio::error::invalid_argument;
+      }
+    }
+    else if (level == ASIO_OS_DEF(IPPROTO_TCP)
+        && optname == ASIO_OS_DEF(TCP_NODELAY))
+    {
+      if (optlen == sizeof(int))
+      {
+        int value = 0;
+        std::memcpy(&value, optval, optlen);
+        impl.socket_->Control->NoDelay = !!value;
+        ec = asio::error_code();
+      }
+      else
+      {
+        ec = asio::error::invalid_argument;
+      }
+    }
+    else
+    {
+      ec = asio::error::invalid_argument;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+  }
+
+  return ec;
+}
+
+void winrt_ssocket_service_base::do_get_option(
+    const winrt_ssocket_service_base::base_implementation_type& impl,
+    int level, int optname, void* optval,
+    std::size_t* optlen, asio::error_code& ec) const
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return;
+  }
+
+  try
+  {
+    if (level == ASIO_OS_DEF(SOL_SOCKET)
+        && optname == ASIO_OS_DEF(SO_KEEPALIVE))
+    {
+      if (*optlen >= sizeof(int))
+      {
+        int value = impl.socket_->Control->KeepAlive ? 1 : 0;
+        std::memcpy(optval, &value, sizeof(int));
+        *optlen = sizeof(int);
+        ec = asio::error_code();
+      }
+      else
+      {
+        ec = asio::error::invalid_argument;
+      }
+    }
+    else if (level == ASIO_OS_DEF(IPPROTO_TCP)
+        && optname == ASIO_OS_DEF(TCP_NODELAY))
+    {
+      if (*optlen >= sizeof(int))
+      {
+        int value = impl.socket_->Control->NoDelay ? 1 : 0;
+        std::memcpy(optval, &value, sizeof(int));
+        *optlen = sizeof(int);
+        ec = asio::error_code();
+      }
+      else
+      {
+        ec = asio::error::invalid_argument;
+      }
+    }
+    else
+    {
+      ec = asio::error::invalid_argument;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+  }
+}
+
+asio::error_code winrt_ssocket_service_base::do_connect(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const void* addr, asio::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return ec;
+  }
+
+  char addr_string[max_addr_v6_str_len];
+  unsigned short port;
+  switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+  {
+  case ASIO_OS_DEF(AF_INET):
+    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET),
+        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
+        addr_string, sizeof(addr_string), 0, ec);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
+    break;
+  case ASIO_OS_DEF(AF_INET6):
+    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET6),
+        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
+        addr_string, sizeof(addr_string), 0, ec);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
+    break;
+  default:
+    ec = asio::error::address_family_not_supported;
+    return ec;
+  }
+
+  if (!ec) try
+  {
+    async_manager_.sync(impl.socket_->ConnectAsync(
+          ref new Windows::Networking::HostName(
+            winrt_utils::string(addr_string)),
+          winrt_utils::string(port)), ec);
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+  }
+
+  return ec;
+}
+
+void winrt_ssocket_service_base::start_connect_op(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const void* addr, winrt_async_op<void>* op, bool is_continuation)
+{
+  if (!is_open(impl))
+  {
+    op->ec_ = asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  char addr_string[max_addr_v6_str_len];
+  unsigned short port = 0;
+  switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+  {
+  case ASIO_OS_DEF(AF_INET):
+    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET),
+        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
+        addr_string, sizeof(addr_string), 0, op->ec_);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
+    break;
+  case ASIO_OS_DEF(AF_INET6):
+    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET6),
+        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
+        addr_string, sizeof(addr_string), 0, op->ec_);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
+    break;
+  default:
+    op->ec_ = asio::error::address_family_not_supported;
+    break;
+  }
+
+  if (op->ec_)
+  {
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    async_manager_.async(impl.socket_->ConnectAsync(
+          ref new Windows::Networking::HostName(
+            winrt_utils::string(addr_string)),
+          winrt_utils::string(port)), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = asio::error_code(
+        e->HResult, asio::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+std::size_t winrt_ssocket_service_base::do_send(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const asio::const_buffer& data,
+    socket_base::message_flags flags, asio::error_code& ec)
+{
+  if (flags)
+  {
+    ec = asio::error::operation_not_supported;
+    return 0;
+  }
+
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return 0;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<asio::const_buffer,
+      asio::const_buffers_1> bufs(asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      ec = asio::error_code();
+      return 0;
+    }
+
+    return async_manager_.sync(
+        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), ec);
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+    return 0;
+  }
+}
+
+void winrt_ssocket_service_base::start_send_op(
+      winrt_ssocket_service_base::base_implementation_type& impl,
+      const asio::const_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<unsigned int>* op, bool is_continuation)
+{
+  if (flags)
+  {
+    op->ec_ = asio::error::operation_not_supported;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (!is_open(impl))
+  {
+    op->ec_ = asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<asio::const_buffer,
+        asio::const_buffers_1> bufs(asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      io_service_.post_immediate_completion(op, is_continuation);
+      return;
+    }
+
+    async_manager_.async(
+        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = asio::error_code(e->HResult,
+        asio::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+std::size_t winrt_ssocket_service_base::do_receive(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const asio::mutable_buffer& data,
+    socket_base::message_flags flags, asio::error_code& ec)
+{
+  if (flags)
+  {
+    ec = asio::error::operation_not_supported;
+    return 0;
+  }
+
+  if (!is_open(impl))
+  {
+    ec = asio::error::bad_descriptor;
+    return 0;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<asio::mutable_buffer,
+        asio::mutable_buffers_1> bufs(asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      ec = asio::error_code();
+      return 0;
+    }
+
+    async_manager_.sync(
+        impl.socket_->InputStream->ReadAsync(
+          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
+          Windows::Storage::Streams::InputStreamOptions::Partial), ec);
+
+    std::size_t bytes_transferred = bufs.buffers()[0]->Length;
+    if (bytes_transferred == 0 && !ec)
+    {
+      ec = asio::error::eof;
+    }
+
+    return bytes_transferred;
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = asio::error_code(e->HResult,
+        asio::system_category());
+    return 0;
+  }
+}
+
+void winrt_ssocket_service_base::start_receive_op(
+      winrt_ssocket_service_base::base_implementation_type& impl,
+      const asio::mutable_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
+      bool is_continuation)
+{
+  if (flags)
+  {
+    op->ec_ = asio::error::operation_not_supported;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (!is_open(impl))
+  {
+    op->ec_ = asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<asio::mutable_buffer,
+        asio::mutable_buffers_1> bufs(asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      io_service_.post_immediate_completion(op, is_continuation);
+      return;
+    }
+
+    async_manager_.async(
+        impl.socket_->InputStream->ReadAsync(
+          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
+          Windows::Storage::Streams::InputStreamOptions::Partial), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = asio::error_code(e->HResult,
+        asio::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+
+#endif // ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.hpp
new file mode 100644
index 0000000..544758d
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.hpp
@@ -0,0 +1,79 @@
+//
+// detail/impl/winrt_timer_scheduler.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
+#define ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Time_Traits>
+void winrt_timer_scheduler::add_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_add_timer_queue(queue);
+}
+
+// Remove a timer queue from the reactor.
+template <typename Time_Traits>
+void winrt_timer_scheduler::remove_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_remove_timer_queue(queue);
+}
+
+template <typename Time_Traits>
+void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue,
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+
+  if (shutdown_)
+  {
+    io_service_.post_immediate_completion(op, false);
+    return;
+  }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    event_.signal(lock);
+}
+
+template <typename Time_Traits>
+std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  lock.unlock();
+  io_service_.post_deferred_completions(ops);
+  return n;
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+
+#endif // ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.ipp
new file mode 100644
index 0000000..c7236c7
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winrt_timer_scheduler.ipp
@@ -0,0 +1,122 @@
+//
+// detail/impl/winrt_timer_scheduler.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
+#define ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+
+#include "asio/detail/bind_handler.hpp"
+#include "asio/detail/winrt_timer_scheduler.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+winrt_timer_scheduler::winrt_timer_scheduler(
+    asio::io_service& io_service)
+  : asio::detail::service_base<winrt_timer_scheduler>(io_service),
+    io_service_(use_service<io_service_impl>(io_service)),
+    mutex_(),
+    event_(),
+    timer_queues_(),
+    thread_(0),
+    stop_thread_(false),
+    shutdown_(false)
+{
+  thread_ = new asio::detail::thread(
+      bind_handler(&winrt_timer_scheduler::call_run_thread, this));
+}
+
+winrt_timer_scheduler::~winrt_timer_scheduler()
+{
+  shutdown_service();
+}
+
+void winrt_timer_scheduler::shutdown_service()
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  shutdown_ = true;
+  stop_thread_ = true;
+  event_.signal(lock);
+  lock.unlock();
+
+  if (thread_)
+  {
+    thread_->join();
+    delete thread_;
+    thread_ = 0;
+  }
+
+  op_queue<operation> ops;
+  timer_queues_.get_all_timers(ops);
+  io_service_.abandon_operations(ops);
+}
+
+void winrt_timer_scheduler::fork_service(asio::io_service::fork_event)
+{
+}
+
+void winrt_timer_scheduler::init_task()
+{
+}
+
+void winrt_timer_scheduler::run_thread()
+{
+  asio::detail::mutex::scoped_lock lock(mutex_);
+  while (!stop_thread_)
+  {
+    const long max_wait_duration = 5 * 60 * 1000000;
+    long wait_duration = timer_queues_.wait_duration_usec(max_wait_duration);
+    event_.wait_for_usec(lock, wait_duration);
+    event_.clear(lock);
+    op_queue<operation> ops;
+    timer_queues_.get_ready_timers(ops);
+    if (!ops.empty())
+    {
+      lock.unlock();
+      io_service_.post_deferred_completions(ops);
+      lock.lock();
+    }
+  }
+}
+
+void winrt_timer_scheduler::call_run_thread(winrt_timer_scheduler* scheduler)
+{
+  scheduler->run_thread();
+}
+
+void winrt_timer_scheduler::do_add_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.insert(&queue);
+}
+
+void winrt_timer_scheduler::do_remove_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.erase(&queue);
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+
+#endif // ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winsock_init.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winsock_init.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winsock_init.ipp
new file mode 100644
index 0000000..9f357f5
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/winsock_init.ipp
@@ -0,0 +1,82 @@
+//
+// detail/impl/winsock_init.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
+#define ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+
+#include "asio/detail/socket_types.hpp"
+#include "asio/detail/winsock_init.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+void winsock_init_base::startup(data& d,
+    unsigned char major, unsigned char minor)
+{
+  if (::InterlockedIncrement(&d.init_count_) == 1)
+  {
+    WSADATA wsa_data;
+    long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data);
+    ::InterlockedExchange(&d.result_, result);
+  }
+}
+
+void winsock_init_base::manual_startup(data& d)
+{
+  if (::InterlockedIncrement(&d.init_count_) == 1)
+  {
+    ::InterlockedExchange(&d.result_, 0);
+  }
+}
+
+void winsock_init_base::cleanup(data& d)
+{
+  if (::InterlockedDecrement(&d.init_count_) == 0)
+  {
+    ::WSACleanup();
+  }
+}
+
+void winsock_init_base::manual_cleanup(data& d)
+{
+  ::InterlockedDecrement(&d.init_count_);
+}
+
+void winsock_init_base::throw_on_error(data& d)
+{
+  long result = ::InterlockedExchangeAdd(&d.result_, 0);
+  if (result != 0)
+  {
+    asio::error_code ec(result,
+        asio::error::get_system_category());
+    asio::detail::throw_error(ec, "winsock");
+  }
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+
+#endif // ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/io_control.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/io_control.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/io_control.hpp
new file mode 100644
index 0000000..3f84c35
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/io_control.hpp
@@ -0,0 +1,134 @@
+//
+// detail/io_control.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_IO_CONTROL_HPP
+#define ASIO_DETAIL_IO_CONTROL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <cstddef>
+#include "asio/detail/socket_types.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+namespace io_control {
+
+// IO control command for non-blocking I/O.
+class non_blocking_io
+{
+public:
+  // Default constructor.
+  non_blocking_io()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific command value.
+  non_blocking_io(bool value)
+    : value_(value ? 1 : 0)
+  {
+  }
+
+  // Get the name of the IO control command.
+  int name() const
+  {
+    return static_cast<int>(ASIO_OS_DEF(FIONBIO));
+  }
+
+  // Set the value of the I/O control command.
+  void set(bool value)
+  {
+    value_ = value ? 1 : 0;
+  }
+
+  // Get the current value of the I/O control command.
+  bool get() const
+  {
+    return value_ != 0;
+  }
+
+  // Get the address of the command data.
+  detail::ioctl_arg_type* data()
+  {
+    return &value_;
+  }
+
+  // Get the address of the command data.
+  const detail::ioctl_arg_type* data() const
+  {
+    return &value_;
+  }
+
+private:
+  detail::ioctl_arg_type value_;
+};
+
+// I/O control command for getting number of bytes available.
+class bytes_readable
+{
+public:
+  // Default constructor.
+  bytes_readable()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific command value.
+  bytes_readable(std::size_t value)
+    : value_(static_cast<detail::ioctl_arg_type>(value))
+  {
+  }
+
+  // Get the name of the IO control command.
+  int name() const
+  {
+    return static_cast<int>(ASIO_OS_DEF(FIONREAD));
+  }
+
+  // Set the value of the I/O control command.
+  void set(std::size_t value)
+  {
+    value_ = static_cast<detail::ioctl_arg_type>(value);
+  }
+
+  // Get the current value of the I/O control command.
+  std::size_t get() const
+  {
+    return static_cast<std::size_t>(value_);
+  }
+
+  // Get the address of the command data.
+  detail::ioctl_arg_type* data()
+  {
+    return &value_;
+  }
+
+  // Get the address of the command data.
+  const detail::ioctl_arg_type* data() const
+  {
+    return &value_;
+  }
+
+private:
+  detail::ioctl_arg_type value_;
+};
+
+} // namespace io_control
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_IO_CONTROL_HPP

http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/keyword_tss_ptr.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/keyword_tss_ptr.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/keyword_tss_ptr.hpp
new file mode 100644
index 0000000..c544403
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/keyword_tss_ptr.hpp
@@ -0,0 +1,70 @@
+//
+// detail/keyword_tss_ptr.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
+#define ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
+
+#include "asio/detail/noncopyable.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename T>
+class keyword_tss_ptr
+  : private noncopyable
+{
+public:
+  // Constructor.
+  keyword_tss_ptr()
+  {
+  }
+
+  // Destructor.
+  ~keyword_tss_ptr()
+  {
+  }
+
+  // Get the value.
+  operator T*() const
+  {
+    return value_;
+  }
+
+  // Set the value.
+  void operator=(T* value)
+  {
+    value_ = value;
+  }
+
+private:
+  static ASIO_THREAD_KEYWORD T* value_;
+};
+
+template <typename T>
+ASIO_THREAD_KEYWORD T* keyword_tss_ptr<T>::value_;
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
+
+#endif // ASIO_DETAIL_KEYWORD_TSS_PTR_HPP