You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by wh...@apache.org on 2015/10/29 18:57:34 UTC
[48/54] [abbrv] [partial] hadoop git commit: HDFS-9207. Move the
implementation to the hdfs-native-client module. Contributed by Haohui Mai.
http://git-wip-us.apache.org/repos/asf/hadoop/blob/76a1e894/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_datagram_socket.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_datagram_socket.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_datagram_socket.hpp
deleted file mode 100644
index a1356b9..0000000
--- a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_datagram_socket.hpp
+++ /dev/null
@@ -1,949 +0,0 @@
-//
-// basic_datagram_socket.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_BASIC_DATAGRAM_SOCKET_HPP
-#define ASIO_BASIC_DATAGRAM_SOCKET_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/basic_socket.hpp"
-#include "asio/datagram_socket_service.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides datagram-oriented socket functionality.
-/**
- * The basic_datagram_socket class template provides asynchronous and blocking
- * datagram-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Protocol,
- typename DatagramSocketService = datagram_socket_service<Protocol> >
-class basic_datagram_socket
- : public basic_socket<Protocol, DatagramSocketService>
-{
-public:
- /// (Deprecated: Use native_handle_type.) The native representation of a
- /// socket.
- typedef typename DatagramSocketService::native_handle_type native_type;
-
- /// The native representation of a socket.
- typedef typename DatagramSocketService::native_handle_type native_handle_type;
-
- /// The protocol type.
- typedef Protocol protocol_type;
-
- /// The endpoint type.
- typedef typename Protocol::endpoint endpoint_type;
-
- /// Construct a basic_datagram_socket without opening it.
- /**
- * This constructor creates a datagram socket without opening it. The open()
- * function must be called before data can be sent or received on the socket.
- *
- * @param io_service The io_service object that the datagram socket will use
- * to dispatch handlers for any asynchronous operations performed on the
- * socket.
- */
- explicit basic_datagram_socket(asio::io_service& io_service)
- : basic_socket<Protocol, DatagramSocketService>(io_service)
- {
- }
-
- /// Construct and open a basic_datagram_socket.
- /**
- * This constructor creates and opens a datagram socket.
- *
- * @param io_service The io_service object that the datagram socket will use
- * to dispatch handlers for any asynchronous operations performed on the
- * socket.
- *
- * @param protocol An object specifying protocol parameters to be used.
- *
- * @throws asio::system_error Thrown on failure.
- */
- basic_datagram_socket(asio::io_service& io_service,
- const protocol_type& protocol)
- : basic_socket<Protocol, DatagramSocketService>(io_service, protocol)
- {
- }
-
- /// Construct a basic_datagram_socket, opening it and binding it to the given
- /// local endpoint.
- /**
- * This constructor creates a datagram socket and automatically opens it bound
- * to the specified endpoint on the local machine. The protocol used is the
- * protocol associated with the given endpoint.
- *
- * @param io_service The io_service object that the datagram socket will use
- * to dispatch handlers for any asynchronous operations performed on the
- * socket.
- *
- * @param endpoint An endpoint on the local machine to which the datagram
- * socket will be bound.
- *
- * @throws asio::system_error Thrown on failure.
- */
- basic_datagram_socket(asio::io_service& io_service,
- const endpoint_type& endpoint)
- : basic_socket<Protocol, DatagramSocketService>(io_service, endpoint)
- {
- }
-
- /// Construct a basic_datagram_socket on an existing native socket.
- /**
- * This constructor creates a datagram socket object to hold an existing
- * native socket.
- *
- * @param io_service The io_service object that the datagram socket will use
- * to dispatch handlers for any asynchronous operations performed on the
- * socket.
- *
- * @param protocol An object specifying protocol parameters to be used.
- *
- * @param native_socket The new underlying socket implementation.
- *
- * @throws asio::system_error Thrown on failure.
- */
- basic_datagram_socket(asio::io_service& io_service,
- const protocol_type& protocol, const native_handle_type& native_socket)
- : basic_socket<Protocol, DatagramSocketService>(
- io_service, protocol, native_socket)
- {
- }
-
-#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
- /// Move-construct a basic_datagram_socket from another.
- /**
- * This constructor moves a datagram socket from one object to another.
- *
- * @param other The other basic_datagram_socket object from which the move
- * will occur.
- *
- * @note Following the move, the moved-from object is in the same state as if
- * constructed using the @c basic_datagram_socket(io_service&) constructor.
- */
- basic_datagram_socket(basic_datagram_socket&& other)
- : basic_socket<Protocol, DatagramSocketService>(
- ASIO_MOVE_CAST(basic_datagram_socket)(other))
- {
- }
-
- /// Move-assign a basic_datagram_socket from another.
- /**
- * This assignment operator moves a datagram socket from one object to
- * another.
- *
- * @param other The other basic_datagram_socket object from which the move
- * will occur.
- *
- * @note Following the move, the moved-from object is in the same state as if
- * constructed using the @c basic_datagram_socket(io_service&) constructor.
- */
- basic_datagram_socket& operator=(basic_datagram_socket&& other)
- {
- basic_socket<Protocol, DatagramSocketService>::operator=(
- ASIO_MOVE_CAST(basic_datagram_socket)(other));
- return *this;
- }
-
- /// Move-construct a basic_datagram_socket from a socket of another protocol
- /// type.
- /**
- * This constructor moves a datagram socket from one object to another.
- *
- * @param other The other basic_datagram_socket object from which the move
- * will occur.
- *
- * @note Following the move, the moved-from object is in the same state as if
- * constructed using the @c basic_datagram_socket(io_service&) constructor.
- */
- template <typename Protocol1, typename DatagramSocketService1>
- basic_datagram_socket(
- basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
- typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
- : basic_socket<Protocol, DatagramSocketService>(
- ASIO_MOVE_CAST2(basic_datagram_socket<
- Protocol1, DatagramSocketService1>)(other))
- {
- }
-
- /// Move-assign a basic_datagram_socket from a socket of another protocol
- /// type.
- /**
- * This assignment operator moves a datagram socket from one object to
- * another.
- *
- * @param other The other basic_datagram_socket object from which the move
- * will occur.
- *
- * @note Following the move, the moved-from object is in the same state as if
- * constructed using the @c basic_datagram_socket(io_service&) constructor.
- */
- template <typename Protocol1, typename DatagramSocketService1>
- typename enable_if<is_convertible<Protocol1, Protocol>::value,
- basic_datagram_socket>::type& operator=(
- basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
- {
- basic_socket<Protocol, DatagramSocketService>::operator=(
- ASIO_MOVE_CAST2(basic_datagram_socket<
- Protocol1, DatagramSocketService1>)(other));
- return *this;
- }
-#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
- /// Send some data on a connected socket.
- /**
- * This function is used to send data on the datagram socket. The function
- * call will block until the data has been sent successfully or an error
- * occurs.
- *
- * @param buffers One ore more data buffers to be sent on the socket.
- *
- * @returns The number of bytes sent.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note The send operation can only be used with a connected socket. Use
- * the send_to function to send data on an unconnected datagram socket.
- *
- * @par Example
- * To send a single data buffer use the @ref buffer function as follows:
- * @code socket.send(asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on sending multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename ConstBufferSequence>
- std::size_t send(const ConstBufferSequence& buffers)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().send(
- this->get_implementation(), buffers, 0, ec);
- asio::detail::throw_error(ec, "send");
- return s;
- }
-
- /// Send some data on a connected socket.
- /**
- * This function is used to send data on the datagram socket. The function
- * call will block until the data has been sent successfully or an error
- * occurs.
- *
- * @param buffers One ore more data buffers to be sent on the socket.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @returns The number of bytes sent.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note The send operation can only be used with a connected socket. Use
- * the send_to function to send data on an unconnected datagram socket.
- */
- template <typename ConstBufferSequence>
- std::size_t send(const ConstBufferSequence& buffers,
- socket_base::message_flags flags)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().send(
- this->get_implementation(), buffers, flags, ec);
- asio::detail::throw_error(ec, "send");
- return s;
- }
-
- /// Send some data on a connected socket.
- /**
- * This function is used to send data on the datagram socket. The function
- * call will block until the data has been sent successfully or an error
- * occurs.
- *
- * @param buffers One or more data buffers to be sent on the socket.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes sent.
- *
- * @note The send operation can only be used with a connected socket. Use
- * the send_to function to send data on an unconnected datagram socket.
- */
- template <typename ConstBufferSequence>
- std::size_t send(const ConstBufferSequence& buffers,
- socket_base::message_flags flags, asio::error_code& ec)
- {
- return this->get_service().send(
- this->get_implementation(), buffers, flags, ec);
- }
-
- /// Start an asynchronous send on a connected socket.
- /**
- * This function is used to asynchronously send data on the datagram socket.
- * The function call always returns immediately.
- *
- * @param buffers One or more data buffers to be sent on the socket. Although
- * the buffers object may be copied as necessary, ownership of the underlying
- * memory blocks is retained by the caller, which must guarantee that they
- * remain valid until the handler is called.
- *
- * @param handler The handler to be called when the send operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes sent.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @note The async_send operation can only be used with a connected socket.
- * Use the async_send_to function to send data on an unconnected datagram
- * socket.
- *
- * @par Example
- * To send a single data buffer use the @ref buffer function as follows:
- * @code
- * socket.async_send(asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on sending multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename ConstBufferSequence, typename WriteHandler>
- ASIO_INITFN_RESULT_TYPE(WriteHandler,
- void (asio::error_code, std::size_t))
- async_send(const ConstBufferSequence& buffers,
- 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.
- ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
- return this->get_service().async_send(this->get_implementation(),
- buffers, 0, ASIO_MOVE_CAST(WriteHandler)(handler));
- }
-
- /// Start an asynchronous send on a connected socket.
- /**
- * This function is used to asynchronously send data on the datagram socket.
- * The function call always returns immediately.
- *
- * @param buffers One or more data buffers to be sent on the socket. Although
- * the buffers object may be copied as necessary, ownership of the underlying
- * memory blocks is retained by the caller, which must guarantee that they
- * remain valid until the handler is called.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @param handler The handler to be called when the send operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes sent.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @note The async_send operation can only be used with a connected socket.
- * Use the async_send_to function to send data on an unconnected datagram
- * socket.
- */
- template <typename ConstBufferSequence, typename WriteHandler>
- ASIO_INITFN_RESULT_TYPE(WriteHandler,
- void (asio::error_code, std::size_t))
- async_send(const ConstBufferSequence& buffers,
- socket_base::message_flags flags,
- 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.
- ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
- return this->get_service().async_send(this->get_implementation(),
- buffers, flags, ASIO_MOVE_CAST(WriteHandler)(handler));
- }
-
- /// Send a datagram to the specified endpoint.
- /**
- * This function is used to send a datagram to the specified remote endpoint.
- * The function call will block until the data has been sent successfully or
- * an error occurs.
- *
- * @param buffers One or more data buffers to be sent to the remote endpoint.
- *
- * @param destination The remote endpoint to which the data will be sent.
- *
- * @returns The number of bytes sent.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To send a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::ip::udp::endpoint destination(
- * asio::ip::address::from_string("1.2.3.4"), 12345);
- * socket.send_to(asio::buffer(data, size), destination);
- * @endcode
- * See the @ref buffer documentation for information on sending multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename ConstBufferSequence>
- std::size_t send_to(const ConstBufferSequence& buffers,
- const endpoint_type& destination)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().send_to(
- this->get_implementation(), buffers, destination, 0, ec);
- asio::detail::throw_error(ec, "send_to");
- return s;
- }
-
- /// Send a datagram to the specified endpoint.
- /**
- * This function is used to send a datagram to the specified remote endpoint.
- * The function call will block until the data has been sent successfully or
- * an error occurs.
- *
- * @param buffers One or more data buffers to be sent to the remote endpoint.
- *
- * @param destination The remote endpoint to which the data will be sent.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @returns The number of bytes sent.
- *
- * @throws asio::system_error Thrown on failure.
- */
- template <typename ConstBufferSequence>
- std::size_t send_to(const ConstBufferSequence& buffers,
- const endpoint_type& destination, socket_base::message_flags flags)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().send_to(
- this->get_implementation(), buffers, destination, flags, ec);
- asio::detail::throw_error(ec, "send_to");
- return s;
- }
-
- /// Send a datagram to the specified endpoint.
- /**
- * This function is used to send a datagram to the specified remote endpoint.
- * The function call will block until the data has been sent successfully or
- * an error occurs.
- *
- * @param buffers One or more data buffers to be sent to the remote endpoint.
- *
- * @param destination The remote endpoint to which the data will be sent.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes sent.
- */
- template <typename ConstBufferSequence>
- std::size_t send_to(const ConstBufferSequence& buffers,
- const endpoint_type& destination, socket_base::message_flags flags,
- asio::error_code& ec)
- {
- return this->get_service().send_to(this->get_implementation(),
- buffers, destination, flags, ec);
- }
-
- /// Start an asynchronous send.
- /**
- * This function is used to asynchronously send a datagram to the specified
- * remote endpoint. The function call always returns immediately.
- *
- * @param buffers One or more data buffers to be sent to the remote endpoint.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param destination The remote endpoint to which the data will be sent.
- * Copies will be made of the endpoint as required.
- *
- * @param handler The handler to be called when the send operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes sent.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @par Example
- * To send a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::ip::udp::endpoint destination(
- * asio::ip::address::from_string("1.2.3.4"), 12345);
- * socket.async_send_to(
- * asio::buffer(data, size), destination, handler);
- * @endcode
- * See the @ref buffer documentation for information on sending multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename ConstBufferSequence, typename WriteHandler>
- ASIO_INITFN_RESULT_TYPE(WriteHandler,
- void (asio::error_code, std::size_t))
- async_send_to(const ConstBufferSequence& buffers,
- const endpoint_type& destination,
- 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.
- ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
- return this->get_service().async_send_to(
- this->get_implementation(), buffers, destination, 0,
- ASIO_MOVE_CAST(WriteHandler)(handler));
- }
-
- /// Start an asynchronous send.
- /**
- * This function is used to asynchronously send a datagram to the specified
- * remote endpoint. The function call always returns immediately.
- *
- * @param buffers One or more data buffers to be sent to the remote endpoint.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param flags Flags specifying how the send call is to be made.
- *
- * @param destination The remote endpoint to which the data will be sent.
- * Copies will be made of the endpoint as required.
- *
- * @param handler The handler to be called when the send operation completes.
- * Copies will be made of the handler as required. The function signature of
- * the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes sent.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- */
- template <typename ConstBufferSequence, typename WriteHandler>
- ASIO_INITFN_RESULT_TYPE(WriteHandler,
- void (asio::error_code, std::size_t))
- async_send_to(const ConstBufferSequence& buffers,
- const endpoint_type& destination, socket_base::message_flags flags,
- 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.
- ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
- return this->get_service().async_send_to(
- this->get_implementation(), buffers, destination, flags,
- ASIO_MOVE_CAST(WriteHandler)(handler));
- }
-
- /// Receive some data on a connected socket.
- /**
- * This function is used to receive data on the datagram socket. The function
- * call will block until data has been received successfully or an error
- * occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @returns The number of bytes received.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note The receive operation can only be used with a connected socket. Use
- * the receive_from function to receive data on an unconnected datagram
- * socket.
- *
- * @par Example
- * To receive into a single data buffer use the @ref buffer function as
- * follows:
- * @code socket.receive(asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on receiving into
- * multiple buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename MutableBufferSequence>
- std::size_t receive(const MutableBufferSequence& buffers)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().receive(
- this->get_implementation(), buffers, 0, ec);
- asio::detail::throw_error(ec, "receive");
- return s;
- }
-
- /// Receive some data on a connected socket.
- /**
- * This function is used to receive data on the datagram socket. The function
- * call will block until data has been received successfully or an error
- * occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @returns The number of bytes received.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note The receive operation can only be used with a connected socket. Use
- * the receive_from function to receive data on an unconnected datagram
- * socket.
- */
- template <typename MutableBufferSequence>
- std::size_t receive(const MutableBufferSequence& buffers,
- socket_base::message_flags flags)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().receive(
- this->get_implementation(), buffers, flags, ec);
- asio::detail::throw_error(ec, "receive");
- return s;
- }
-
- /// Receive some data on a connected socket.
- /**
- * This function is used to receive data on the datagram socket. The function
- * call will block until data has been received successfully or an error
- * occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes received.
- *
- * @note The receive operation can only be used with a connected socket. Use
- * the receive_from function to receive data on an unconnected datagram
- * socket.
- */
- template <typename MutableBufferSequence>
- std::size_t receive(const MutableBufferSequence& buffers,
- socket_base::message_flags flags, asio::error_code& ec)
- {
- return this->get_service().receive(
- this->get_implementation(), buffers, flags, ec);
- }
-
- /// Start an asynchronous receive on a connected socket.
- /**
- * This function is used to asynchronously receive data from the datagram
- * socket. The function call always returns immediately.
- *
- * @param buffers One or more buffers into which the data will be received.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param handler The handler to be called when the receive operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes received.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @note The async_receive operation can only be used with a connected socket.
- * Use the async_receive_from function to receive data on an unconnected
- * datagram socket.
- *
- * @par Example
- * To receive into a single data buffer use the @ref buffer function as
- * follows:
- * @code
- * socket.async_receive(asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on receiving into
- * multiple buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename MutableBufferSequence, typename ReadHandler>
- ASIO_INITFN_RESULT_TYPE(ReadHandler,
- void (asio::error_code, std::size_t))
- async_receive(const MutableBufferSequence& buffers,
- 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.
- ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
- return this->get_service().async_receive(this->get_implementation(),
- buffers, 0, ASIO_MOVE_CAST(ReadHandler)(handler));
- }
-
- /// Start an asynchronous receive on a connected socket.
- /**
- * This function is used to asynchronously receive data from the datagram
- * socket. The function call always returns immediately.
- *
- * @param buffers One or more buffers into which the data will be received.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @param handler The handler to be called when the receive operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes received.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @note The async_receive operation can only be used with a connected socket.
- * Use the async_receive_from function to receive data on an unconnected
- * datagram socket.
- */
- template <typename MutableBufferSequence, typename ReadHandler>
- ASIO_INITFN_RESULT_TYPE(ReadHandler,
- void (asio::error_code, std::size_t))
- async_receive(const MutableBufferSequence& buffers,
- socket_base::message_flags flags,
- 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.
- ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
- return this->get_service().async_receive(this->get_implementation(),
- buffers, flags, ASIO_MOVE_CAST(ReadHandler)(handler));
- }
-
- /// Receive a datagram with the endpoint of the sender.
- /**
- * This function is used to receive a datagram. The function call will block
- * until data has been received successfully or an error occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @param sender_endpoint An endpoint object that receives the endpoint of
- * the remote sender of the datagram.
- *
- * @returns The number of bytes received.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To receive into a single data buffer use the @ref buffer function as
- * follows:
- * @code
- * asio::ip::udp::endpoint sender_endpoint;
- * socket.receive_from(
- * asio::buffer(data, size), sender_endpoint);
- * @endcode
- * See the @ref buffer documentation for information on receiving into
- * multiple buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename MutableBufferSequence>
- std::size_t receive_from(const MutableBufferSequence& buffers,
- endpoint_type& sender_endpoint)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().receive_from(
- this->get_implementation(), buffers, sender_endpoint, 0, ec);
- asio::detail::throw_error(ec, "receive_from");
- return s;
- }
-
- /// Receive a datagram with the endpoint of the sender.
- /**
- * This function is used to receive a datagram. The function call will block
- * until data has been received successfully or an error occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @param sender_endpoint An endpoint object that receives the endpoint of
- * the remote sender of the datagram.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @returns The number of bytes received.
- *
- * @throws asio::system_error Thrown on failure.
- */
- template <typename MutableBufferSequence>
- std::size_t receive_from(const MutableBufferSequence& buffers,
- endpoint_type& sender_endpoint, socket_base::message_flags flags)
- {
- asio::error_code ec;
- std::size_t s = this->get_service().receive_from(
- this->get_implementation(), buffers, sender_endpoint, flags, ec);
- asio::detail::throw_error(ec, "receive_from");
- return s;
- }
-
- /// Receive a datagram with the endpoint of the sender.
- /**
- * This function is used to receive a datagram. The function call will block
- * until data has been received successfully or an error occurs.
- *
- * @param buffers One or more buffers into which the data will be received.
- *
- * @param sender_endpoint An endpoint object that receives the endpoint of
- * the remote sender of the datagram.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes received.
- */
- template <typename MutableBufferSequence>
- std::size_t receive_from(const MutableBufferSequence& buffers,
- endpoint_type& sender_endpoint, socket_base::message_flags flags,
- asio::error_code& ec)
- {
- return this->get_service().receive_from(this->get_implementation(),
- buffers, sender_endpoint, flags, ec);
- }
-
- /// Start an asynchronous receive.
- /**
- * This function is used to asynchronously receive a datagram. The function
- * call always returns immediately.
- *
- * @param buffers One or more buffers into which the data will be received.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param sender_endpoint An endpoint object that receives the endpoint of
- * the remote sender of the datagram. Ownership of the sender_endpoint object
- * is retained by the caller, which must guarantee that it is valid until the
- * handler is called.
- *
- * @param handler The handler to be called when the receive operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes received.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- *
- * @par Example
- * To receive into a single data buffer use the @ref buffer function as
- * follows:
- * @code socket.async_receive_from(
- * asio::buffer(data, size), sender_endpoint, handler); @endcode
- * See the @ref buffer documentation for information on receiving into
- * multiple buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
- template <typename MutableBufferSequence, typename ReadHandler>
- ASIO_INITFN_RESULT_TYPE(ReadHandler,
- void (asio::error_code, std::size_t))
- async_receive_from(const MutableBufferSequence& buffers,
- endpoint_type& sender_endpoint,
- 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.
- ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
- return this->get_service().async_receive_from(
- this->get_implementation(), buffers, sender_endpoint, 0,
- ASIO_MOVE_CAST(ReadHandler)(handler));
- }
-
- /// Start an asynchronous receive.
- /**
- * This function is used to asynchronously receive a datagram. The function
- * call always returns immediately.
- *
- * @param buffers One or more buffers into which the data will be received.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the handler is called.
- *
- * @param sender_endpoint An endpoint object that receives the endpoint of
- * the remote sender of the datagram. Ownership of the sender_endpoint object
- * is retained by the caller, which must guarantee that it is valid until the
- * handler is called.
- *
- * @param flags Flags specifying how the receive call is to be made.
- *
- * @param handler The handler to be called when the receive operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- * const asio::error_code& error, // Result of operation.
- * std::size_t bytes_transferred // Number of bytes received.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- */
- template <typename MutableBufferSequence, typename ReadHandler>
- ASIO_INITFN_RESULT_TYPE(ReadHandler,
- void (asio::error_code, std::size_t))
- async_receive_from(const MutableBufferSequence& buffers,
- endpoint_type& sender_endpoint, socket_base::message_flags flags,
- 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.
- ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
- return this->get_service().async_receive_from(
- this->get_implementation(), buffers, sender_endpoint, flags,
- ASIO_MOVE_CAST(ReadHandler)(handler));
- }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_DATAGRAM_SOCKET_HPP
http://git-wip-us.apache.org/repos/asf/hadoop/blob/76a1e894/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_deadline_timer.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_deadline_timer.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_deadline_timer.hpp
deleted file mode 100644
index d0fc371..0000000
--- a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_deadline_timer.hpp
+++ /dev/null
@@ -1,520 +0,0 @@
-//
-// basic_deadline_timer.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_BASIC_DEADLINE_TIMER_HPP
-#define ASIO_BASIC_DEADLINE_TIMER_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_BOOST_DATE_TIME) \
- || defined(ASIO_CPP11_DATE_TIME) \
- || defined(GENERATING_DOCUMENTATION)
-
-#include <cstddef>
-#include "asio/basic_io_object.hpp"
-#include "asio/deadline_timer_service.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides waitable timer functionality.
-/**
- * The basic_deadline_timer class template provides the ability to perform a
- * blocking or asynchronous wait for a timer to expire.
- *
- * A deadline timer is always in one of two states: "expired" or "not expired".
- * If the wait() or async_wait() function is called on an expired timer, the
- * wait operation will complete immediately.
- *
- * Most applications will use the asio::deadline_timer typedef.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Examples
- * Performing a blocking wait:
- * @code
- * // Construct a timer without setting an expiry time.
- * asio::deadline_timer timer(io_service);
- *
- * // Set an expiry time relative to now.
- * timer.expires_from_now(boost::posix_time::seconds(5));
- *
- * // Wait for the timer to expire.
- * timer.wait();
- * @endcode
- *
- * @par
- * Performing an asynchronous wait:
- * @code
- * void handler(const asio::error_code& error)
- * {
- * if (!error)
- * {
- * // Timer expired.
- * }
- * }
- *
- * ...
- *
- * // Construct a timer with an absolute expiry time.
- * asio::deadline_timer timer(io_service,
- * boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
- *
- * // Start an asynchronous wait.
- * timer.async_wait(handler);
- * @endcode
- *
- * @par Changing an active deadline_timer's expiry time
- *
- * Changing the expiry time of a timer while there are pending asynchronous
- * waits causes those wait operations to be cancelled. To ensure that the action
- * associated with the timer is performed only once, use something like this:
- * used:
- *
- * @code
- * void on_some_event()
- * {
- * if (my_timer.expires_from_now(seconds(5)) > 0)
- * {
- * // We managed to cancel the timer. Start new asynchronous wait.
- * my_timer.async_wait(on_timeout);
- * }
- * else
- * {
- * // Too late, timer has already expired!
- * }
- * }
- *
- * void on_timeout(const asio::error_code& e)
- * {
- * if (e != asio::error::operation_aborted)
- * {
- * // Timer was not cancelled, take necessary action.
- * }
- * }
- * @endcode
- *
- * @li The asio::basic_deadline_timer::expires_from_now() function
- * cancels any pending asynchronous waits, and returns the number of
- * asynchronous waits that were cancelled. If it returns 0 then you were too
- * late and the wait handler has already been executed, or will soon be
- * executed. If it returns 1 then the wait handler was successfully cancelled.
- *
- * @li If a wait handler is cancelled, the asio::error_code passed to
- * it contains the value asio::error::operation_aborted.
- */
-template <typename Time,
- typename TimeTraits = asio::time_traits<Time>,
- typename TimerService = deadline_timer_service<Time, TimeTraits> >
-class basic_deadline_timer
- : public basic_io_object<TimerService>
-{
-public:
- /// The time traits type.
- typedef TimeTraits traits_type;
-
- /// The time type.
- typedef typename traits_type::time_type time_type;
-
- /// The duration type.
- typedef typename traits_type::duration_type duration_type;
-
- /// Constructor.
- /**
- * This constructor creates a timer without setting an expiry time. The
- * expires_at() or expires_from_now() functions must be called to set an
- * expiry time before the timer can be waited on.
- *
- * @param io_service The io_service object that the timer will use to dispatch
- * handlers for any asynchronous operations performed on the timer.
- */
- explicit basic_deadline_timer(asio::io_service& io_service)
- : basic_io_object<TimerService>(io_service)
- {
- }
-
- /// Constructor to set a particular expiry time as an absolute time.
- /**
- * This constructor creates a timer and sets the expiry time.
- *
- * @param io_service The io_service object that the timer will use to dispatch
- * handlers for any asynchronous operations performed on the timer.
- *
- * @param expiry_time The expiry time to be used for the timer, expressed
- * as an absolute time.
- */
- basic_deadline_timer(asio::io_service& io_service,
- const time_type& expiry_time)
- : basic_io_object<TimerService>(io_service)
- {
- asio::error_code ec;
- this->service.expires_at(this->implementation, expiry_time, ec);
- asio::detail::throw_error(ec, "expires_at");
- }
-
- /// Constructor to set a particular expiry time relative to now.
- /**
- * This constructor creates a timer and sets the expiry time.
- *
- * @param io_service The io_service object that the timer will use to dispatch
- * handlers for any asynchronous operations performed on the timer.
- *
- * @param expiry_time The expiry time to be used for the timer, relative to
- * now.
- */
- basic_deadline_timer(asio::io_service& io_service,
- const duration_type& expiry_time)
- : basic_io_object<TimerService>(io_service)
- {
- asio::error_code ec;
- this->service.expires_from_now(this->implementation, expiry_time, ec);
- asio::detail::throw_error(ec, "expires_from_now");
- }
-
- /// Cancel any asynchronous operations that are waiting on the timer.
- /**
- * This function forces the completion of any pending asynchronous wait
- * operations against the timer. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * Cancelling the timer does not change the expiry time.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note If the timer has already expired when cancel() is called, then the
- * handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t cancel()
- {
- asio::error_code ec;
- std::size_t s = this->service.cancel(this->implementation, ec);
- asio::detail::throw_error(ec, "cancel");
- return s;
- }
-
- /// Cancel any asynchronous operations that are waiting on the timer.
- /**
- * This function forces the completion of any pending asynchronous wait
- * operations against the timer. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * Cancelling the timer does not change the expiry time.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @note If the timer has already expired when cancel() is called, then the
- * handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t cancel(asio::error_code& ec)
- {
- return this->service.cancel(this->implementation, ec);
- }
-
- /// Cancels one asynchronous operation that is waiting on the timer.
- /**
- * This function forces the completion of one pending asynchronous wait
- * operation against the timer. Handlers are cancelled in FIFO order. The
- * handler for the cancelled operation will be invoked with the
- * asio::error::operation_aborted error code.
- *
- * Cancelling the timer does not change the expiry time.
- *
- * @return The number of asynchronous operations that were cancelled. That is,
- * either 0 or 1.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note If the timer has already expired when cancel_one() is called, then
- * the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t cancel_one()
- {
- asio::error_code ec;
- std::size_t s = this->service.cancel_one(this->implementation, ec);
- asio::detail::throw_error(ec, "cancel_one");
- return s;
- }
-
- /// Cancels one asynchronous operation that is waiting on the timer.
- /**
- * This function forces the completion of one pending asynchronous wait
- * operation against the timer. Handlers are cancelled in FIFO order. The
- * handler for the cancelled operation will be invoked with the
- * asio::error::operation_aborted error code.
- *
- * Cancelling the timer does not change the expiry time.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @return The number of asynchronous operations that were cancelled. That is,
- * either 0 or 1.
- *
- * @note If the timer has already expired when cancel_one() is called, then
- * the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t cancel_one(asio::error_code& ec)
- {
- return this->service.cancel_one(this->implementation, ec);
- }
-
- /// Get the timer's expiry time as an absolute time.
- /**
- * This function may be used to obtain the timer's current expiry time.
- * Whether the timer has expired or not does not affect this value.
- */
- time_type expires_at() const
- {
- return this->service.expires_at(this->implementation);
- }
-
- /// Set the timer's expiry time as an absolute time.
- /**
- * This function sets the expiry time. Any pending asynchronous wait
- * operations will be cancelled. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * @param expiry_time The expiry time to be used for the timer.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note If the timer has already expired when expires_at() is called, then
- * the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t expires_at(const time_type& expiry_time)
- {
- asio::error_code ec;
- std::size_t s = this->service.expires_at(
- this->implementation, expiry_time, ec);
- asio::detail::throw_error(ec, "expires_at");
- return s;
- }
-
- /// Set the timer's expiry time as an absolute time.
- /**
- * This function sets the expiry time. Any pending asynchronous wait
- * operations will be cancelled. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * @param expiry_time The expiry time to be used for the timer.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @note If the timer has already expired when expires_at() is called, then
- * the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t expires_at(const time_type& expiry_time,
- asio::error_code& ec)
- {
- return this->service.expires_at(this->implementation, expiry_time, ec);
- }
-
- /// Get the timer's expiry time relative to now.
- /**
- * This function may be used to obtain the timer's current expiry time.
- * Whether the timer has expired or not does not affect this value.
- */
- duration_type expires_from_now() const
- {
- return this->service.expires_from_now(this->implementation);
- }
-
- /// Set the timer's expiry time relative to now.
- /**
- * This function sets the expiry time. Any pending asynchronous wait
- * operations will be cancelled. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * @param expiry_time The expiry time to be used for the timer.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note If the timer has already expired when expires_from_now() is called,
- * then the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t expires_from_now(const duration_type& expiry_time)
- {
- asio::error_code ec;
- std::size_t s = this->service.expires_from_now(
- this->implementation, expiry_time, ec);
- asio::detail::throw_error(ec, "expires_from_now");
- return s;
- }
-
- /// Set the timer's expiry time relative to now.
- /**
- * This function sets the expiry time. Any pending asynchronous wait
- * operations will be cancelled. The handler for each cancelled operation will
- * be invoked with the asio::error::operation_aborted error code.
- *
- * @param expiry_time The expiry time to be used for the timer.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @return The number of asynchronous operations that were cancelled.
- *
- * @note If the timer has already expired when expires_from_now() is called,
- * then the handlers for asynchronous wait operations will:
- *
- * @li have already been invoked; or
- *
- * @li have been queued for invocation in the near future.
- *
- * These handlers can no longer be cancelled, and therefore are passed an
- * error code that indicates the successful completion of the wait operation.
- */
- std::size_t expires_from_now(const duration_type& expiry_time,
- asio::error_code& ec)
- {
- return this->service.expires_from_now(
- this->implementation, expiry_time, ec);
- }
-
- /// Perform a blocking wait on the timer.
- /**
- * This function is used to wait for the timer to expire. This function
- * blocks and does not return until the timer has expired.
- *
- * @throws asio::system_error Thrown on failure.
- */
- void wait()
- {
- asio::error_code ec;
- this->service.wait(this->implementation, ec);
- asio::detail::throw_error(ec, "wait");
- }
-
- /// Perform a blocking wait on the timer.
- /**
- * This function is used to wait for the timer to expire. This function
- * blocks and does not return until the timer has expired.
- *
- * @param ec Set to indicate what error occurred, if any.
- */
- void wait(asio::error_code& ec)
- {
- this->service.wait(this->implementation, ec);
- }
-
- /// Start an asynchronous wait on the timer.
- /**
- * This function may be used to initiate an asynchronous wait against the
- * timer. It always returns immediately.
- *
- * For each call to async_wait(), the supplied handler will be called exactly
- * once. The handler will be called when:
- *
- * @li The timer has expired.
- *
- * @li The timer was cancelled, in which case the handler is passed the error
- * code asio::error::operation_aborted.
- *
- * @param handler The handler to be called when the timer expires. Copies
- * will be made of the handler as required. The function signature of the
- * handler must be:
- * @code void handler(
- * const asio::error_code& error // Result of operation.
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the handler will not be invoked from within this function. Invocation
- * of the handler will be performed in a manner equivalent to using
- * asio::io_service::post().
- */
- template <typename WaitHandler>
- ASIO_INITFN_RESULT_TYPE(WaitHandler,
- void (asio::error_code))
- async_wait(ASIO_MOVE_ARG(WaitHandler) handler)
- {
- // If you get an error on the following line it means that your handler does
- // not meet the documented type requirements for a WaitHandler.
- ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
- return this->service.async_wait(this->implementation,
- ASIO_MOVE_CAST(WaitHandler)(handler));
- }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
- // || defined(ASIO_CPP11_DATE_TIME)
- // || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_DEADLINE_TIMER_HPP
http://git-wip-us.apache.org/repos/asf/hadoop/blob/76a1e894/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_io_object.hpp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_io_object.hpp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_io_object.hpp
deleted file mode 100644
index 6154d92..0000000
--- a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/basic_io_object.hpp
+++ /dev/null
@@ -1,240 +0,0 @@
-//
-// basic_io_object.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_BASIC_IO_OBJECT_HPP
-#define ASIO_BASIC_IO_OBJECT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(ASIO_HAS_MOVE)
-namespace detail
-{
- // Type trait used to determine whether a service supports move.
- template <typename IoObjectService>
- class service_has_move
- {
- private:
- typedef IoObjectService service_type;
- typedef typename service_type::implementation_type implementation_type;
-
- template <typename T, typename U>
- static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
- static char (&eval(...))[2];
-
- public:
- static const bool value =
- sizeof(service_has_move::eval(
- static_cast<service_type*>(0),
- static_cast<implementation_type*>(0))) == 1;
- };
-}
-#endif // defined(ASIO_HAS_MOVE)
-
-/// Base class for all I/O objects.
-/**
- * @note All I/O objects are non-copyable. However, when using C++0x, certain
- * I/O objects do support move construction and move assignment.
- */
-#if !defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-template <typename IoObjectService>
-#else
-template <typename IoObjectService,
- bool Movable = detail::service_has_move<IoObjectService>::value>
-#endif
-class basic_io_object
-{
-public:
- /// The type of the service that will be used to provide I/O operations.
- typedef IoObjectService service_type;
-
- /// The underlying implementation type of I/O object.
- typedef typename service_type::implementation_type implementation_type;
-
- /// Get the io_service associated with the object.
- /**
- * This function may be used to obtain the io_service object that the I/O
- * object uses to dispatch handlers for asynchronous operations.
- *
- * @return A reference to the io_service object that the I/O object will use
- * to dispatch handlers. Ownership is not transferred to the caller.
- */
- asio::io_service& get_io_service()
- {
- return service.get_io_service();
- }
-
-protected:
- /// Construct a basic_io_object.
- /**
- * Performs:
- * @code get_service().construct(get_implementation()); @endcode
- */
- explicit basic_io_object(asio::io_service& io_service)
- : service(asio::use_service<IoObjectService>(io_service))
- {
- service.construct(implementation);
- }
-
-#if defined(GENERATING_DOCUMENTATION)
- /// Move-construct a basic_io_object.
- /**
- * Performs:
- * @code get_service().move_construct(
- * get_implementation(), other.get_implementation()); @endcode
- *
- * @note Available only for services that support movability,
- */
- basic_io_object(basic_io_object&& other);
-
- /// Move-assign a basic_io_object.
- /**
- * Performs:
- * @code get_service().move_assign(get_implementation(),
- * other.get_service(), other.get_implementation()); @endcode
- *
- * @note Available only for services that support movability,
- */
- basic_io_object& operator=(basic_io_object&& other);
-#endif // defined(GENERATING_DOCUMENTATION)
-
- /// Protected destructor to prevent deletion through this type.
- /**
- * Performs:
- * @code get_service().destroy(get_implementation()); @endcode
- */
- ~basic_io_object()
- {
- service.destroy(implementation);
- }
-
- /// Get the service associated with the I/O object.
- service_type& get_service()
- {
- return service;
- }
-
- /// Get the service associated with the I/O object.
- const service_type& get_service() const
- {
- return service;
- }
-
- /// (Deprecated: Use get_service().) The service associated with the I/O
- /// object.
- /**
- * @note Available only for services that do not support movability.
- */
- service_type& service;
-
- /// Get the underlying implementation of the I/O object.
- implementation_type& get_implementation()
- {
- return implementation;
- }
-
- /// Get the underlying implementation of the I/O object.
- const implementation_type& get_implementation() const
- {
- return implementation;
- }
-
- /// (Deprecated: Use get_implementation().) The underlying implementation of
- /// the I/O object.
- implementation_type implementation;
-
-private:
- basic_io_object(const basic_io_object&);
- basic_io_object& operator=(const basic_io_object&);
-};
-
-#if defined(ASIO_HAS_MOVE)
-// Specialisation for movable objects.
-template <typename IoObjectService>
-class basic_io_object<IoObjectService, true>
-{
-public:
- typedef IoObjectService service_type;
- typedef typename service_type::implementation_type implementation_type;
-
- asio::io_service& get_io_service()
- {
- return service_->get_io_service();
- }
-
-protected:
- explicit basic_io_object(asio::io_service& io_service)
- : service_(&asio::use_service<IoObjectService>(io_service))
- {
- service_->construct(implementation);
- }
-
- basic_io_object(basic_io_object&& other)
- : service_(&other.get_service())
- {
- service_->move_construct(implementation, other.implementation);
- }
-
- ~basic_io_object()
- {
- service_->destroy(implementation);
- }
-
- basic_io_object& operator=(basic_io_object&& other)
- {
- service_->move_assign(implementation,
- *other.service_, other.implementation);
- service_ = other.service_;
- return *this;
- }
-
- service_type& get_service()
- {
- return *service_;
- }
-
- const service_type& get_service() const
- {
- return *service_;
- }
-
- implementation_type& get_implementation()
- {
- return implementation;
- }
-
- const implementation_type& get_implementation() const
- {
- return implementation;
- }
-
- implementation_type implementation;
-
-private:
- basic_io_object(const basic_io_object&);
- void operator=(const basic_io_object&);
-
- IoObjectService* service_;
-};
-#endif // defined(ASIO_HAS_MOVE)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_IO_OBJECT_HPP