http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffer.hpp ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffer.hpp b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffer.hpp deleted file mode 100644 index afd5d04..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffer.hpp +++ /dev/null @@ -1,2239 +0,0 @@ -// -// buffer.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_BUFFER_HPP -#define ASIO_BUFFER_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 <cstring> -#include <string> -#include <vector> -#include "asio/detail/array_fwd.hpp" - -#if defined(ASIO_MSVC) -# if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0) -# if !defined(ASIO_DISABLE_BUFFER_DEBUGGING) -# define ASIO_ENABLE_BUFFER_DEBUGGING -# endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING) -# endif // defined(_HAS_ITERATOR_DEBUGGING) -#endif // defined(ASIO_MSVC) - -#if defined(__GNUC__) -# if defined(_GLIBCXX_DEBUG) -# if !defined(ASIO_DISABLE_BUFFER_DEBUGGING) -# define ASIO_ENABLE_BUFFER_DEBUGGING -# endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING) -# endif // defined(_GLIBCXX_DEBUG) -#endif // defined(__GNUC__) - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) -# include "asio/detail/function.hpp" -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - -#if defined(ASIO_HAS_BOOST_WORKAROUND) -# include <boost/detail/workaround.hpp> -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \ - || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) -# define ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND -# endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) - // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) -#endif // defined(ASIO_HAS_BOOST_WORKAROUND) - -#if defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND) -# include "asio/detail/type_traits.hpp" -#endif // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND) - -#include "asio/detail/push_options.hpp" - -namespace asio { - -class mutable_buffer; -class const_buffer; - -namespace detail { -void* buffer_cast_helper(const mutable_buffer&); -const void* buffer_cast_helper(const const_buffer&); -std::size_t buffer_size_helper(const mutable_buffer&); -std::size_t buffer_size_helper(const const_buffer&); -} // namespace detail - -/// Holds a buffer that can be modified. -/** - * The mutable_buffer class provides a safe representation of a buffer that can - * be modified. It does not own the underlying data, and so is cheap to copy or - * assign. - * - * @par Accessing Buffer Contents - * - * The contents of a buffer may be accessed using the @ref buffer_size - * and @ref buffer_cast functions: - * - * @code asio::mutable_buffer b1 = ...; - * std::size_t s1 = asio::buffer_size(b1); - * unsigned char* p1 = asio::buffer_cast<unsigned char*>(b1); - * @endcode - * - * The asio::buffer_cast function permits violations of type safety, so - * uses of it in application code should be carefully considered. - */ -class mutable_buffer -{ -public: - /// Construct an empty buffer. - mutable_buffer() - : data_(0), - size_(0) - { - } - - /// Construct a buffer to represent a given memory range. - mutable_buffer(void* data, std::size_t size) - : data_(data), - size_(size) - { - } - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - mutable_buffer(void* data, std::size_t size, - asio::detail::function<void()> debug_check) - : data_(data), - size_(size), - debug_check_(debug_check) - { - } - - const asio::detail::function<void()>& get_debug_check() const - { - return debug_check_; - } -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - -private: - friend void* asio::detail::buffer_cast_helper( - const mutable_buffer& b); - friend std::size_t asio::detail::buffer_size_helper( - const mutable_buffer& b); - - void* data_; - std::size_t size_; - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - asio::detail::function<void()> debug_check_; -#endif // ASIO_ENABLE_BUFFER_DEBUGGING -}; - -namespace detail { - -inline void* buffer_cast_helper(const mutable_buffer& b) -{ -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - if (b.size_ && b.debug_check_) - b.debug_check_(); -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - return b.data_; -} - -inline std::size_t buffer_size_helper(const mutable_buffer& b) -{ - return b.size_; -} - -} // namespace detail - -/// Adapts a single modifiable buffer so that it meets the requirements of the -/// MutableBufferSequence concept. -class mutable_buffers_1 - : public mutable_buffer -{ -public: - /// The type for each element in the list of buffers. - typedef mutable_buffer value_type; - - /// A random-access iterator type that may be used to read elements. - typedef const mutable_buffer* const_iterator; - - /// Construct to represent a given memory range. - mutable_buffers_1(void* data, std::size_t size) - : mutable_buffer(data, size) - { - } - - /// Construct to represent a single modifiable buffer. - explicit mutable_buffers_1(const mutable_buffer& b) - : mutable_buffer(b) - { - } - - /// Get a random-access iterator to the first element. - const_iterator begin() const - { - return this; - } - - /// Get a random-access iterator for one past the last element. - const_iterator end() const - { - return begin() + 1; - } -}; - -/// Holds a buffer that cannot be modified. -/** - * The const_buffer class provides a safe representation of a buffer that cannot - * be modified. It does not own the underlying data, and so is cheap to copy or - * assign. - * - * @par Accessing Buffer Contents - * - * The contents of a buffer may be accessed using the @ref buffer_size - * and @ref buffer_cast functions: - * - * @code asio::const_buffer b1 = ...; - * std::size_t s1 = asio::buffer_size(b1); - * const unsigned char* p1 = asio::buffer_cast<const unsigned char*>(b1); - * @endcode - * - * The asio::buffer_cast function permits violations of type safety, so - * uses of it in application code should be carefully considered. - */ -class const_buffer -{ -public: - /// Construct an empty buffer. - const_buffer() - : data_(0), - size_(0) - { - } - - /// Construct a buffer to represent a given memory range. - const_buffer(const void* data, std::size_t size) - : data_(data), - size_(size) - { - } - - /// Construct a non-modifiable buffer from a modifiable one. - const_buffer(const mutable_buffer& b) - : data_(asio::detail::buffer_cast_helper(b)), - size_(asio::detail::buffer_size_helper(b)) -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , debug_check_(b.get_debug_check()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - { - } - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - const_buffer(const void* data, std::size_t size, - asio::detail::function<void()> debug_check) - : data_(data), - size_(size), - debug_check_(debug_check) - { - } - - const asio::detail::function<void()>& get_debug_check() const - { - return debug_check_; - } -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - -private: - friend const void* asio::detail::buffer_cast_helper( - const const_buffer& b); - friend std::size_t asio::detail::buffer_size_helper( - const const_buffer& b); - - const void* data_; - std::size_t size_; - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - asio::detail::function<void()> debug_check_; -#endif // ASIO_ENABLE_BUFFER_DEBUGGING -}; - -namespace detail { - -inline const void* buffer_cast_helper(const const_buffer& b) -{ -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - if (b.size_ && b.debug_check_) - b.debug_check_(); -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - return b.data_; -} - -inline std::size_t buffer_size_helper(const const_buffer& b) -{ - return b.size_; -} - -} // namespace detail - -/// Adapts a single non-modifiable buffer so that it meets the requirements of -/// the ConstBufferSequence concept. -class const_buffers_1 - : public const_buffer -{ -public: - /// The type for each element in the list of buffers. - typedef const_buffer value_type; - - /// A random-access iterator type that may be used to read elements. - typedef const const_buffer* const_iterator; - - /// Construct to represent a given memory range. - const_buffers_1(const void* data, std::size_t size) - : const_buffer(data, size) - { - } - - /// Construct to represent a single non-modifiable buffer. - explicit const_buffers_1(const const_buffer& b) - : const_buffer(b) - { - } - - /// Get a random-access iterator to the first element. - const_iterator begin() const - { - return this; - } - - /// Get a random-access iterator for one past the last element. - const_iterator end() const - { - return begin() + 1; - } -}; - -/// An implementation of both the ConstBufferSequence and MutableBufferSequence -/// concepts to represent a null buffer sequence. -class null_buffers -{ -public: - /// The type for each element in the list of buffers. - typedef mutable_buffer value_type; - - /// A random-access iterator type that may be used to read elements. - typedef const mutable_buffer* const_iterator; - - /// Get a random-access iterator to the first element. - const_iterator begin() const - { - return &buf_; - } - - /// Get a random-access iterator for one past the last element. - const_iterator end() const - { - return &buf_; - } - -private: - mutable_buffer buf_; -}; - -/** @defgroup buffer_size asio::buffer_size - * - * @brief The asio::buffer_size function determines the total number of - * bytes in a buffer or buffer sequence. - */ -/*@{*/ - -/// Get the number of bytes in a modifiable buffer. -inline std::size_t buffer_size(const mutable_buffer& b) -{ - return detail::buffer_size_helper(b); -} - -/// Get the number of bytes in a modifiable buffer. -inline std::size_t buffer_size(const mutable_buffers_1& b) -{ - return detail::buffer_size_helper(b); -} - -/// Get the number of bytes in a non-modifiable buffer. -inline std::size_t buffer_size(const const_buffer& b) -{ - return detail::buffer_size_helper(b); -} - -/// Get the number of bytes in a non-modifiable buffer. -inline std::size_t buffer_size(const const_buffers_1& b) -{ - return detail::buffer_size_helper(b); -} - -/// Get the total number of bytes in a buffer sequence. -/** - * The @c BufferSequence template parameter may meet either of the @c - * ConstBufferSequence or @c MutableBufferSequence type requirements. - */ -template <typename BufferSequence> -inline std::size_t buffer_size(const BufferSequence& b) -{ - std::size_t total_buffer_size = 0; - - typename BufferSequence::const_iterator iter = b.begin(); - typename BufferSequence::const_iterator end = b.end(); - for (; iter != end; ++iter) - total_buffer_size += detail::buffer_size_helper(*iter); - - return total_buffer_size; -} - -/*@}*/ - -/** @defgroup buffer_cast asio::buffer_cast - * - * @brief The asio::buffer_cast function is used to obtain a pointer to - * the underlying memory region associated with a buffer. - * - * @par Examples: - * - * To access the memory of a non-modifiable buffer, use: - * @code asio::const_buffer b1 = ...; - * const unsigned char* p1 = asio::buffer_cast<const unsigned char*>(b1); - * @endcode - * - * To access the memory of a modifiable buffer, use: - * @code asio::mutable_buffer b2 = ...; - * unsigned char* p2 = asio::buffer_cast<unsigned char*>(b2); - * @endcode - * - * The asio::buffer_cast function permits violations of type safety, so - * uses of it in application code should be carefully considered. - */ -/*@{*/ - -/// Cast a non-modifiable buffer to a specified pointer to POD type. -template <typename PointerToPodType> -inline PointerToPodType buffer_cast(const mutable_buffer& b) -{ - return static_cast<PointerToPodType>(detail::buffer_cast_helper(b)); -} - -/// Cast a non-modifiable buffer to a specified pointer to POD type. -template <typename PointerToPodType> -inline PointerToPodType buffer_cast(const const_buffer& b) -{ - return static_cast<PointerToPodType>(detail::buffer_cast_helper(b)); -} - -/*@}*/ - -/// Create a new modifiable buffer that is offset from the start of another. -/** - * @relates mutable_buffer - */ -inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start) -{ - if (start > buffer_size(b)) - return mutable_buffer(); - char* new_data = buffer_cast<char*>(b) + start; - std::size_t new_size = buffer_size(b) - start; - return mutable_buffer(new_data, new_size -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - ); -} - -/// Create a new modifiable buffer that is offset from the start of another. -/** - * @relates mutable_buffer - */ -inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b) -{ - if (start > buffer_size(b)) - return mutable_buffer(); - char* new_data = buffer_cast<char*>(b) + start; - std::size_t new_size = buffer_size(b) - start; - return mutable_buffer(new_data, new_size -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - ); -} - -/// Create a new non-modifiable buffer that is offset from the start of another. -/** - * @relates const_buffer - */ -inline const_buffer operator+(const const_buffer& b, std::size_t start) -{ - if (start > buffer_size(b)) - return const_buffer(); - const char* new_data = buffer_cast<const char*>(b) + start; - std::size_t new_size = buffer_size(b) - start; - return const_buffer(new_data, new_size -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - ); -} - -/// Create a new non-modifiable buffer that is offset from the start of another. -/** - * @relates const_buffer - */ -inline const_buffer operator+(std::size_t start, const const_buffer& b) -{ - if (start > buffer_size(b)) - return const_buffer(); - const char* new_data = buffer_cast<const char*>(b) + start; - std::size_t new_size = buffer_size(b) - start; - return const_buffer(new_data, new_size -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - ); -} - -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) -namespace detail { - -template <typename Iterator> -class buffer_debug_check -{ -public: - buffer_debug_check(Iterator iter) - : iter_(iter) - { - } - - ~buffer_debug_check() - { -#if defined(ASIO_MSVC) && (ASIO_MSVC == 1400) - // MSVC 8's string iterator checking may crash in a std::string::iterator - // object's destructor when the iterator points to an already-destroyed - // std::string object, unless the iterator is cleared first. - iter_ = Iterator(); -#endif // defined(ASIO_MSVC) && (ASIO_MSVC == 1400) - } - - void operator()() - { - *iter_; - } - -private: - Iterator iter_; -}; - -} // namespace detail -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - -/** @defgroup buffer asio::buffer - * - * @brief The asio::buffer function is used to create a buffer object to - * represent raw memory, an array of POD elements, a vector of POD elements, - * or a std::string. - * - * A buffer object represents a contiguous region of memory as a 2-tuple - * consisting of a pointer and size in bytes. A tuple of the form <tt>{void*, - * size_t}</tt> specifies a mutable (modifiable) region of memory. Similarly, a - * tuple of the form <tt>{const void*, size_t}</tt> specifies a const - * (non-modifiable) region of memory. These two forms correspond to the classes - * mutable_buffer and const_buffer, respectively. To mirror C++'s conversion - * rules, a mutable_buffer is implicitly convertible to a const_buffer, and the - * opposite conversion is not permitted. - * - * The simplest use case involves reading or writing a single buffer of a - * specified size: - * - * @code sock.send(asio::buffer(data, size)); @endcode - * - * In the above example, the return value of asio::buffer meets the - * requirements of the ConstBufferSequence concept so that it may be directly - * passed to the socket's write function. A buffer created for modifiable - * memory also meets the requirements of the MutableBufferSequence concept. - * - * An individual buffer may be created from a builtin array, std::vector, - * std::array or boost::array of POD elements. This helps prevent buffer - * overruns by automatically determining the size of the buffer: - * - * @code char d1[128]; - * size_t bytes_transferred = sock.receive(asio::buffer(d1)); - * - * std::vector<char> d2(128); - * bytes_transferred = sock.receive(asio::buffer(d2)); - * - * std::array<char, 128> d3; - * bytes_transferred = sock.receive(asio::buffer(d3)); - * - * boost::array<char, 128> d4; - * bytes_transferred = sock.receive(asio::buffer(d4)); @endcode - * - * In all three cases above, the buffers created are exactly 128 bytes long. - * Note that a vector is @e never automatically resized when creating or using - * a buffer. The buffer size is determined using the vector's <tt>size()</tt> - * member function, and not its capacity. - * - * @par Accessing Buffer Contents - * - * The contents of a buffer may be accessed using the @ref buffer_size and - * @ref buffer_cast functions: - * - * @code asio::mutable_buffer b1 = ...; - * std::size_t s1 = asio::buffer_size(b1); - * unsigned char* p1 = asio::buffer_cast<unsigned char*>(b1); - * - * asio::const_buffer b2 = ...; - * std::size_t s2 = asio::buffer_size(b2); - * const void* p2 = asio::buffer_cast<const void*>(b2); @endcode - * - * The asio::buffer_cast function permits violations of type safety, so - * uses of it in application code should be carefully considered. - * - * For convenience, the @ref buffer_size function also works on buffer - * sequences (that is, types meeting the ConstBufferSequence or - * MutableBufferSequence type requirements). In this case, the function returns - * the total size of all buffers in the sequence. - * - * @par Buffer Copying - * - * The @ref buffer_copy function may be used to copy raw bytes between - * individual buffers and buffer sequences. - * - * In particular, when used with the @ref buffer_size, the @ref buffer_copy - * function can be used to linearise a sequence of buffers. For example: - * - * @code vector<const_buffer> buffers = ...; - * - * vector<unsigned char> data(asio::buffer_size(buffers)); - * asio::buffer_copy(asio::buffer(data), buffers); @endcode - * - * Note that @ref buffer_copy is implemented in terms of @c memcpy, and - * consequently it cannot be used to copy between overlapping memory regions. - * - * @par Buffer Invalidation - * - * A buffer object does not have any ownership of the memory it refers to. It - * is the responsibility of the application to ensure the memory region remains - * valid until it is no longer required for an I/O operation. When the memory - * is no longer available, the buffer is said to have been invalidated. - * - * For the asio::buffer overloads that accept an argument of type - * std::vector, the buffer objects returned are invalidated by any vector - * operation that also invalidates all references, pointers and iterators - * referring to the elements in the sequence (C++ Std, 23.2.4) - * - * For the asio::buffer overloads that accept an argument of type - * std::basic_string, the buffer objects returned are invalidated according to - * the rules defined for invalidation of references, pointers and iterators - * referring to elements of the sequence (C++ Std, 21.3). - * - * @par Buffer Arithmetic - * - * Buffer objects may be manipulated using simple arithmetic in a safe way - * which helps prevent buffer overruns. Consider an array initialised as - * follows: - * - * @code boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; @endcode - * - * A buffer object @c b1 created using: - * - * @code b1 = asio::buffer(a); @endcode - * - * represents the entire array, <tt>{ 'a', 'b', 'c', 'd', 'e' }</tt>. An - * optional second argument to the asio::buffer function may be used to - * limit the size, in bytes, of the buffer: - * - * @code b2 = asio::buffer(a, 3); @endcode - * - * such that @c b2 represents the data <tt>{ 'a', 'b', 'c' }</tt>. Even if the - * size argument exceeds the actual size of the array, the size of the buffer - * object created will be limited to the array size. - * - * An offset may be applied to an existing buffer to create a new one: - * - * @code b3 = b1 + 2; @endcode - * - * where @c b3 will set to represent <tt>{ 'c', 'd', 'e' }</tt>. If the offset - * exceeds the size of the existing buffer, the newly created buffer will be - * empty. - * - * Both an offset and size may be specified to create a buffer that corresponds - * to a specific range of bytes within an existing buffer: - * - * @code b4 = asio::buffer(b1 + 1, 3); @endcode - * - * so that @c b4 will refer to the bytes <tt>{ 'b', 'c', 'd' }</tt>. - * - * @par Buffers and Scatter-Gather I/O - * - * To read or write using multiple buffers (i.e. scatter-gather I/O), multiple - * buffer objects may be assigned into a container that supports the - * MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts: - * - * @code - * char d1[128]; - * std::vector<char> d2(128); - * boost::array<char, 128> d3; - * - * boost::array<mutable_buffer, 3> bufs1 = { - * asio::buffer(d1), - * asio::buffer(d2), - * asio::buffer(d3) }; - * bytes_transferred = sock.receive(bufs1); - * - * std::vector<const_buffer> bufs2; - * bufs2.push_back(asio::buffer(d1)); - * bufs2.push_back(asio::buffer(d2)); - * bufs2.push_back(asio::buffer(d3)); - * bytes_transferred = sock.send(bufs2); @endcode - */ -/*@{*/ - -/// Create a new modifiable buffer from an existing buffer. -/** - * @returns <tt>mutable_buffers_1(b)</tt>. - */ -inline mutable_buffers_1 buffer(const mutable_buffer& b) -{ - return mutable_buffers_1(b); -} - -/// Create a new modifiable buffer from an existing buffer. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * buffer_cast<void*>(b), - * min(buffer_size(b), max_size_in_bytes)); @endcode - */ -inline mutable_buffers_1 buffer(const mutable_buffer& b, - std::size_t max_size_in_bytes) -{ - return mutable_buffers_1( - mutable_buffer(buffer_cast<void*>(b), - buffer_size(b) < max_size_in_bytes - ? buffer_size(b) : max_size_in_bytes -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new non-modifiable buffer from an existing buffer. -/** - * @returns <tt>const_buffers_1(b)</tt>. - */ -inline const_buffers_1 buffer(const const_buffer& b) -{ - return const_buffers_1(b); -} - -/// Create a new non-modifiable buffer from an existing buffer. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * buffer_cast<const void*>(b), - * min(buffer_size(b), max_size_in_bytes)); @endcode - */ -inline const_buffers_1 buffer(const const_buffer& b, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(buffer_cast<const void*>(b), - buffer_size(b) < max_size_in_bytes - ? buffer_size(b) : max_size_in_bytes -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , b.get_debug_check() -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new modifiable buffer that represents the given memory range. -/** - * @returns <tt>mutable_buffers_1(data, size_in_bytes)</tt>. - */ -inline mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes) -{ - return mutable_buffers_1(mutable_buffer(data, size_in_bytes)); -} - -/// Create a new non-modifiable buffer that represents the given memory range. -/** - * @returns <tt>const_buffers_1(data, size_in_bytes)</tt>. - */ -inline const_buffers_1 buffer(const void* data, - std::size_t size_in_bytes) -{ - return const_buffers_1(const_buffer(data, size_in_bytes)); -} - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * static_cast<void*>(data), - * N * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(PodType (&data)[N]) -{ - return mutable_buffers_1(mutable_buffer(data, N * sizeof(PodType))); -} - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * static_cast<void*>(data), - * min(N * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(PodType (&data)[N], - std::size_t max_size_in_bytes) -{ - return mutable_buffers_1( - mutable_buffer(data, - N * sizeof(PodType) < max_size_in_bytes - ? N * sizeof(PodType) : max_size_in_bytes)); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * static_cast<const void*>(data), - * N * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const PodType (&data)[N]) -{ - return const_buffers_1(const_buffer(data, N * sizeof(PodType))); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * static_cast<const void*>(data), - * min(N * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const PodType (&data)[N], - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data, - N * sizeof(PodType) < max_size_in_bytes - ? N * sizeof(PodType) : max_size_in_bytes)); -} - -#if defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND) - -// Borland C++ and Sun Studio think the overloads: -// -// unspecified buffer(boost::array<PodType, N>& array ...); -// -// and -// -// unspecified buffer(boost::array<const PodType, N>& array ...); -// -// are ambiguous. This will be worked around by using a buffer_types traits -// class that contains typedefs for the appropriate buffer and container -// classes, based on whether PodType is const or non-const. - -namespace detail { - -template <bool IsConst> -struct buffer_types_base; - -template <> -struct buffer_types_base<false> -{ - typedef mutable_buffer buffer_type; - typedef mutable_buffers_1 container_type; -}; - -template <> -struct buffer_types_base<true> -{ - typedef const_buffer buffer_type; - typedef const_buffers_1 container_type; -}; - -template <typename PodType> -struct buffer_types - : public buffer_types_base<is_const<PodType>::value> -{ -}; - -} // namespace detail - -template <typename PodType, std::size_t N> -inline typename detail::buffer_types<PodType>::container_type -buffer(boost::array<PodType, N>& data) -{ - typedef typename asio::detail::buffer_types<PodType>::buffer_type - buffer_type; - typedef typename asio::detail::buffer_types<PodType>::container_type - container_type; - return container_type( - buffer_type(data.c_array(), data.size() * sizeof(PodType))); -} - -template <typename PodType, std::size_t N> -inline typename detail::buffer_types<PodType>::container_type -buffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes) -{ - typedef typename asio::detail::buffer_types<PodType>::buffer_type - buffer_type; - typedef typename asio::detail::buffer_types<PodType>::container_type - container_type; - return container_type( - buffer_type(data.c_array(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -#else // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND) - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(boost::array<PodType, N>& data) -{ - return mutable_buffers_1( - mutable_buffer(data.c_array(), data.size() * sizeof(PodType))); -} - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(boost::array<PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return mutable_buffers_1( - mutable_buffer(data.c_array(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(boost::array<const PodType, N>& data) -{ - return const_buffers_1( - const_buffer(data.data(), data.size() * sizeof(PodType))); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(boost::array<const PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.data(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -#endif // defined(ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND) - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const boost::array<PodType, N>& data) -{ - return const_buffers_1( - const_buffer(data.data(), data.size() * sizeof(PodType))); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const boost::array<PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.data(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -#if defined(ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION) - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(std::array<PodType, N>& data) -{ - return mutable_buffers_1( - mutable_buffer(data.data(), data.size() * sizeof(PodType))); -} - -/// Create a new modifiable buffer that represents the given POD array. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline mutable_buffers_1 buffer(std::array<PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return mutable_buffers_1( - mutable_buffer(data.data(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(std::array<const PodType, N>& data) -{ - return const_buffers_1( - const_buffer(data.data(), data.size() * sizeof(PodType))); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(std::array<const PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.data(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * data.size() * sizeof(PodType)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const std::array<PodType, N>& data) -{ - return const_buffers_1( - const_buffer(data.data(), data.size() * sizeof(PodType))); -} - -/// Create a new non-modifiable buffer that represents the given POD array. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - */ -template <typename PodType, std::size_t N> -inline const_buffers_1 buffer(const std::array<PodType, N>& data, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.data(), - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes)); -} - -#endif // defined(ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION) - -/// Create a new modifiable buffer that represents the given POD vector. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.size() ? &data[0] : 0, - * data.size() * sizeof(PodType)); @endcode - * - * @note The buffer is invalidated by any vector operation that would also - * invalidate iterators. - */ -template <typename PodType, typename Allocator> -inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data) -{ - return mutable_buffers_1( - mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType) -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::vector<PodType, Allocator>::iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new modifiable buffer that represents the given POD vector. -/** - * @returns A mutable_buffers_1 value equivalent to: - * @code mutable_buffers_1( - * data.size() ? &data[0] : 0, - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - * - * @note The buffer is invalidated by any vector operation that would also - * invalidate iterators. - */ -template <typename PodType, typename Allocator> -inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data, - std::size_t max_size_in_bytes) -{ - return mutable_buffers_1( - mutable_buffer(data.size() ? &data[0] : 0, - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::vector<PodType, Allocator>::iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new non-modifiable buffer that represents the given POD vector. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.size() ? &data[0] : 0, - * data.size() * sizeof(PodType)); @endcode - * - * @note The buffer is invalidated by any vector operation that would also - * invalidate iterators. - */ -template <typename PodType, typename Allocator> -inline const_buffers_1 buffer( - const std::vector<PodType, Allocator>& data) -{ - return const_buffers_1( - const_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType) -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::vector<PodType, Allocator>::const_iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new non-modifiable buffer that represents the given POD vector. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.size() ? &data[0] : 0, - * min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode - * - * @note The buffer is invalidated by any vector operation that would also - * invalidate iterators. - */ -template <typename PodType, typename Allocator> -inline const_buffers_1 buffer( - const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.size() ? &data[0] : 0, - data.size() * sizeof(PodType) < max_size_in_bytes - ? data.size() * sizeof(PodType) : max_size_in_bytes -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::vector<PodType, Allocator>::const_iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new non-modifiable buffer that represents the given string. -/** - * @returns <tt>const_buffers_1(data.data(), data.size() * sizeof(Elem))</tt>. - * - * @note The buffer is invalidated by any non-const operation called on the - * given string object. - */ -template <typename Elem, typename Traits, typename Allocator> -inline const_buffers_1 buffer( - const std::basic_string<Elem, Traits, Allocator>& data) -{ - return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem) -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::basic_string<Elem, Traits, Allocator>::const_iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/// Create a new non-modifiable buffer that represents the given string. -/** - * @returns A const_buffers_1 value equivalent to: - * @code const_buffers_1( - * data.data(), - * min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode - * - * @note The buffer is invalidated by any non-const operation called on the - * given string object. - */ -template <typename Elem, typename Traits, typename Allocator> -inline const_buffers_1 buffer( - const std::basic_string<Elem, Traits, Allocator>& data, - std::size_t max_size_in_bytes) -{ - return const_buffers_1( - const_buffer(data.data(), - data.size() * sizeof(Elem) < max_size_in_bytes - ? data.size() * sizeof(Elem) : max_size_in_bytes -#if defined(ASIO_ENABLE_BUFFER_DEBUGGING) - , detail::buffer_debug_check< - typename std::basic_string<Elem, Traits, Allocator>::const_iterator - >(data.begin()) -#endif // ASIO_ENABLE_BUFFER_DEBUGGING - )); -} - -/*@}*/ - -/** @defgroup buffer_copy asio::buffer_copy - * - * @brief The asio::buffer_copy function is used to copy bytes from a - * source buffer (or buffer sequence) to a target buffer (or buffer sequence). - * - * The @c buffer_copy function is available in two forms: - * - * @li A 2-argument form: @c buffer_copy(target, source) - * - * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy) - - * Both forms return the number of bytes actually copied. The number of bytes - * copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c If specified, @c max_bytes_to_copy. - * - * This prevents buffer overflow, regardless of the buffer sizes used in the - * copy operation. - * - * Note that @ref buffer_copy is implemented in terms of @c memcpy, and - * consequently it cannot be used to copy between overlapping memory regions. - */ -/*@{*/ - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const const_buffer& source) -{ - using namespace std; // For memcpy. - std::size_t target_size = buffer_size(target); - std::size_t source_size = buffer_size(source); - std::size_t n = target_size < source_size ? target_size : source_size; - memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n); - return n; -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const const_buffers_1& source) -{ - return buffer_copy(target, static_cast<const const_buffer&>(source)); -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const mutable_buffer& source) -{ - return buffer_copy(target, const_buffer(source)); -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const mutable_buffers_1& source) -{ - return buffer_copy(target, const_buffer(source)); -} - -/// Copies bytes from a source buffer sequence to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename ConstBufferSequence> -std::size_t buffer_copy(const mutable_buffer& target, - const ConstBufferSequence& source) -{ - std::size_t total_bytes_copied = 0; - - typename ConstBufferSequence::const_iterator source_iter = source.begin(); - typename ConstBufferSequence::const_iterator source_end = source.end(); - - for (mutable_buffer target_buffer(target); - buffer_size(target_buffer) && source_iter != source_end; ++source_iter) - { - const_buffer source_buffer(*source_iter); - std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); - total_bytes_copied += bytes_copied; - target_buffer = target_buffer + bytes_copied; - } - - return total_bytes_copied; -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const const_buffer& source) -{ - return buffer_copy(static_cast<const mutable_buffer&>(target), source); -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const const_buffers_1& source) -{ - return buffer_copy(static_cast<const mutable_buffer&>(target), - static_cast<const const_buffer&>(source)); -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const mutable_buffer& source) -{ - return buffer_copy(static_cast<const mutable_buffer&>(target), - const_buffer(source)); -} - -/// Copies bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const mutable_buffers_1& source) -{ - return buffer_copy(static_cast<const mutable_buffer&>(target), - const_buffer(source)); -} - -/// Copies bytes from a source buffer sequence to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename ConstBufferSequence> -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const ConstBufferSequence& source) -{ - return buffer_copy(static_cast<const mutable_buffer&>(target), source); -} - -/// Copies bytes from a source buffer to a target buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -std::size_t buffer_copy(const MutableBufferSequence& target, - const const_buffer& source) -{ - std::size_t total_bytes_copied = 0; - - typename MutableBufferSequence::const_iterator target_iter = target.begin(); - typename MutableBufferSequence::const_iterator target_end = target.end(); - - for (const_buffer source_buffer(source); - buffer_size(source_buffer) && target_iter != target_end; ++target_iter) - { - mutable_buffer target_buffer(*target_iter); - std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); - total_bytes_copied += bytes_copied; - source_buffer = source_buffer + bytes_copied; - } - - return total_bytes_copied; -} - -/// Copies bytes from a source buffer to a target buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const const_buffers_1& source) -{ - return buffer_copy(target, static_cast<const const_buffer&>(source)); -} - -/// Copies bytes from a source buffer to a target buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const mutable_buffer& source) -{ - return buffer_copy(target, const_buffer(source)); -} - -/// Copies bytes from a source buffer to a target buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const mutable_buffers_1& source) -{ - return buffer_copy(target, const_buffer(source)); -} - -/// Copies bytes from a source buffer sequence to a target buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence, typename ConstBufferSequence> -std::size_t buffer_copy(const MutableBufferSequence& target, - const ConstBufferSequence& source) -{ - std::size_t total_bytes_copied = 0; - - typename MutableBufferSequence::const_iterator target_iter = target.begin(); - typename MutableBufferSequence::const_iterator target_end = target.end(); - std::size_t target_buffer_offset = 0; - - typename ConstBufferSequence::const_iterator source_iter = source.begin(); - typename ConstBufferSequence::const_iterator source_end = source.end(); - std::size_t source_buffer_offset = 0; - - while (target_iter != target_end && source_iter != source_end) - { - mutable_buffer target_buffer = - mutable_buffer(*target_iter) + target_buffer_offset; - - const_buffer source_buffer = - const_buffer(*source_iter) + source_buffer_offset; - - std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer); - total_bytes_copied += bytes_copied; - - if (bytes_copied == buffer_size(target_buffer)) - { - ++target_iter; - target_buffer_offset = 0; - } - else - target_buffer_offset += bytes_copied; - - if (bytes_copied == buffer_size(source_buffer)) - { - ++source_iter; - source_buffer_offset = 0; - } - else - source_buffer_offset += bytes_copied; - } - - return total_bytes_copied; -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const const_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const const_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const mutable_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffer& target, - const mutable_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer sequence to a target -/// buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename ConstBufferSequence> -inline std::size_t buffer_copy(const mutable_buffer& target, - const ConstBufferSequence& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const const_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const const_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const mutable_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const mutable_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer sequence to a target -/// buffer. -/** - * @param target A modifiable buffer representing the memory region to which - * the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename ConstBufferSequence> -inline std::size_t buffer_copy(const mutable_buffers_1& target, - const ConstBufferSequence& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(buffer(target, max_bytes_to_copy), source); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer -/// sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const const_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(target, buffer(source, max_bytes_to_copy)); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer -/// sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer representing the memory region from - * which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const const_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(target, buffer(source, max_bytes_to_copy)); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer -/// sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const mutable_buffer& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(target, buffer(source, max_bytes_to_copy)); -} - -/// Copies a limited number of bytes from a source buffer to a target buffer -/// sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A modifiable buffer representing the memory region from which - * the bytes will be copied. The contents of the source buffer will not be - * modified. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence> -inline std::size_t buffer_copy(const MutableBufferSequence& target, - const mutable_buffers_1& source, std::size_t max_bytes_to_copy) -{ - return buffer_copy(target, buffer(source, max_bytes_to_copy)); -} - -/// Copies a limited number of bytes from a source buffer sequence to a target -/// buffer sequence. -/** - * @param target A modifiable buffer sequence representing the memory regions to - * which the bytes will be copied. - * - * @param source A non-modifiable buffer sequence representing the memory - * regions from which the bytes will be copied. - * - * @param max_bytes_to_copy The maximum number of bytes to be copied. - * - * @returns The number of bytes copied. - * - * @note The number of bytes copied is the lesser of: - * - * @li @c buffer_size(target) - * - * @li @c buffer_size(source) - * - * @li @c max_bytes_to_copy - * - * This function is implemented in terms of @c memcpy, and consequently it - * cannot be used to copy between overlapping memory regions. - */ -template <typename MutableBufferSequence, typename ConstBufferSequence> -std::size_t buffer_copy(const MutableBufferSequence& target, - const ConstBufferSequence& source, std::size_t max_bytes_to_copy) -{ - std::size_t total_bytes_copied = 0; - - typename MutableBufferSequence::const_iterator target_iter = target.begin(); - typename MutableBufferSequence::const_iterator target_end = target.end(); - std::size_t target_buffer_offset = 0; - - typename ConstBufferSequence::const_iterator source_iter = source.begin(); - typename ConstBufferSequence::const_iterator source_end = source.end(); - std::size_t source_buffer_offset = 0; - - while (total_bytes_copied != max_bytes_to_copy - && target_iter != target_end && source_iter != source_end) - { - mutable_buffer target_buffer = - mutable_buffer(*target_iter) + target_buffer_offset; - - const_buffer source_buffer = - const_buffer(*source_iter) + source_buffer_offset; - - std::size_t bytes_copied = buffer_copy(target_buffer, - source_buffer, max_bytes_to_copy - total_bytes_copied); - total_bytes_copied += bytes_copied; - - if (bytes_copied == buffer_size(target_buffer)) - { - ++target_iter; - target_buffer_offset = 0; - } - else - target_buffer_offset += bytes_copied; - - if (bytes_copied == buffer_size(source_buffer)) - { - ++source_iter; - source_buffer_offset = 0; - } - else - source_buffer_offset += bytes_copied; - } - - return total_bytes_copied; -} - -/*@}*/ - -} // namespace asio - -#include "asio/detail/pop_options.hpp" - -#endif // ASIO_BUFFER_HPP
http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream.hpp ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream.hpp b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream.hpp deleted file mode 100644 index 15e6cff..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream.hpp +++ /dev/null @@ -1,244 +0,0 @@ -// -// buffered_read_stream.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_BUFFERED_READ_STREAM_HPP -#define ASIO_BUFFERED_READ_STREAM_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/async_result.hpp" -#include "asio/buffered_read_stream_fwd.hpp" -#include "asio/buffer.hpp" -#include "asio/detail/bind_handler.hpp" -#include "asio/detail/buffer_resize_guard.hpp" -#include "asio/detail/buffered_stream_storage.hpp" -#include "asio/detail/noncopyable.hpp" -#include "asio/detail/type_traits.hpp" -#include "asio/error.hpp" -#include "asio/io_service.hpp" - -#include "asio/detail/push_options.hpp" - -namespace asio { - -/// Adds buffering to the read-related operations of a stream. -/** - * The buffered_read_stream class template can be used to add buffering to the - * synchronous and asynchronous read operations of a stream. - * - * @par Thread Safety - * @e Distinct @e objects: Safe.@n - * @e Shared @e objects: Unsafe. - * - * @par Concepts: - * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream. - */ -template <typename Stream> -class buffered_read_stream - : private noncopyable -{ -public: - /// The type of the next layer. - typedef typename remove_reference<Stream>::type next_layer_type; - - /// The type of the lowest layer. - typedef typename next_layer_type::lowest_layer_type lowest_layer_type; - -#if defined(GENERATING_DOCUMENTATION) - /// The default buffer size. - static const std::size_t default_buffer_size = implementation_defined; -#else - ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024); -#endif - - /// Construct, passing the specified argument to initialise the next layer. - template <typename Arg> - explicit buffered_read_stream(Arg& a) - : next_layer_(a), - storage_(default_buffer_size) - { - } - - /// Construct, passing the specified argument to initialise the next layer. - template <typename Arg> - buffered_read_stream(Arg& a, std::size_t buffer_size) - : next_layer_(a), - storage_(buffer_size) - { - } - - /// Get a reference to the next layer. - next_layer_type& next_layer() - { - return next_layer_; - } - - /// Get a reference to the lowest layer. - lowest_layer_type& lowest_layer() - { - return next_layer_.lowest_layer(); - } - - /// Get a const reference to the lowest layer. - const lowest_layer_type& lowest_layer() const - { - return next_layer_.lowest_layer(); - } - - /// Get the io_service associated with the object. - asio::io_service& get_io_service() - { - return next_layer_.get_io_service(); - } - - /// Close the stream. - void close() - { - next_layer_.close(); - } - - /// Close the stream. - asio::error_code close(asio::error_code& ec) - { - return next_layer_.close(ec); - } - - /// Write the given data to the stream. Returns the number of bytes written. - /// Throws an exception on failure. - template <typename ConstBufferSequence> - std::size_t write_some(const ConstBufferSequence& buffers) - { - return next_layer_.write_some(buffers); - } - - /// Write the given data to the stream. Returns the number of bytes written, - /// or 0 if an error occurred. - template <typename ConstBufferSequence> - std::size_t write_some(const ConstBufferSequence& buffers, - asio::error_code& ec) - { - return next_layer_.write_some(buffers, ec); - } - - /// Start an asynchronous write. The data being written must be valid for the - /// lifetime of the asynchronous operation. - template <typename ConstBufferSequence, typename WriteHandler> - ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) - async_write_some(const ConstBufferSequence& buffers, - ASIO_MOVE_ARG(WriteHandler) handler) - { - detail::async_result_init< - WriteHandler, void (asio::error_code, std::size_t)> init( - ASIO_MOVE_CAST(WriteHandler)(handler)); - - next_layer_.async_write_some(buffers, - ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(WriteHandler, - void (asio::error_code, std::size_t)))(init.handler)); - - return init.result.get(); - } - - /// Fill the buffer with some data. Returns the number of bytes placed in the - /// buffer as a result of the operation. Throws an exception on failure. - std::size_t fill(); - - /// Fill the buffer with some data. Returns the number of bytes placed in the - /// buffer as a result of the operation, or 0 if an error occurred. - std::size_t fill(asio::error_code& ec); - - /// Start an asynchronous fill. - template <typename ReadHandler> - ASIO_INITFN_RESULT_TYPE(ReadHandler, - void (asio::error_code, std::size_t)) - async_fill(ASIO_MOVE_ARG(ReadHandler) handler); - - /// Read some data from the stream. Returns the number of bytes read. Throws - /// an exception on failure. - template <typename MutableBufferSequence> - std::size_t read_some(const MutableBufferSequence& buffers); - - /// Read some data from the stream. Returns the number of bytes read or 0 if - /// an error occurred. - template <typename MutableBufferSequence> - std::size_t read_some(const MutableBufferSequence& buffers, - asio::error_code& ec); - - /// Start an asynchronous read. The buffer into which the data will be read - /// must be valid for the lifetime of the asynchronous operation. - template <typename MutableBufferSequence, typename ReadHandler> - ASIO_INITFN_RESULT_TYPE(ReadHandler, - void (asio::error_code, std::size_t)) - async_read_some(const MutableBufferSequence& buffers, - ASIO_MOVE_ARG(ReadHandler) handler); - - /// Peek at the incoming data on the stream. Returns the number of bytes read. - /// Throws an exception on failure. - template <typename MutableBufferSequence> - std::size_t peek(const MutableBufferSequence& buffers); - - /// Peek at the incoming data on the stream. Returns the number of bytes read, - /// or 0 if an error occurred. - template <typename MutableBufferSequence> - std::size_t peek(const MutableBufferSequence& buffers, - asio::error_code& ec); - - /// Determine the amount of data that may be read without blocking. - std::size_t in_avail() - { - return storage_.size(); - } - - /// Determine the amount of data that may be read without blocking. - std::size_t in_avail(asio::error_code& ec) - { - ec = asio::error_code(); - return storage_.size(); - } - -private: - /// Copy data out of the internal buffer to the specified target buffer. - /// Returns the number of bytes copied. - template <typename MutableBufferSequence> - std::size_t copy(const MutableBufferSequence& buffers) - { - std::size_t bytes_copied = asio::buffer_copy( - buffers, storage_.data(), storage_.size()); - storage_.consume(bytes_copied); - return bytes_copied; - } - - /// Copy data from the internal buffer to the specified target buffer, without - /// removing the data from the internal buffer. Returns the number of bytes - /// copied. - template <typename MutableBufferSequence> - std::size_t peek_copy(const MutableBufferSequence& buffers) - { - return asio::buffer_copy(buffers, storage_.data(), storage_.size()); - } - - /// The next layer. - Stream next_layer_; - - // The data in the buffer. - detail::buffered_stream_storage storage_; -}; - -} // namespace asio - -#include "asio/detail/pop_options.hpp" - -#include "asio/impl/buffered_read_stream.hpp" - -#endif // ASIO_BUFFERED_READ_STREAM_HPP http://git-wip-us.apache.org/repos/asf/hadoop/blob/7a542fb3/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream_fwd.hpp ---------------------------------------------------------------------- diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream_fwd.hpp b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream_fwd.hpp deleted file mode 100644 index 9bac634..0000000 --- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/buffered_read_stream_fwd.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// -// buffered_read_stream_fwd.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_BUFFERED_READ_STREAM_FWD_HPP -#define ASIO_BUFFERED_READ_STREAM_FWD_HPP - -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) - -namespace asio { - -template <typename Stream> -class buffered_read_stream; - -} // namespace asio - -#endif // ASIO_BUFFERED_READ_STREAM_FWD_HPP --------------------------------------------------------------------- To unsubscribe, e-mail: common-commits-unsubscr...@hadoop.apache.org For additional commands, e-mail: common-commits-h...@hadoop.apache.org
