[Boost-commit] svn:boost r46415 - in trunk: boost boost/asio libs/asio/test

From: chris_at_[hidden]
Date: 2008-06-15 20:41:30

Author: chris_kohlhoff
Date: 2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
New Revision: 46415
URL: http://svn.boost.org/trac/boost/changeset/46415

Log:
Add an iterator for bytewise traversal of a buffer sequence.

Added:
   trunk/boost/asio/buffers_iterator.hpp   (contents, props changed)
   trunk/libs/asio/test/buffers_iterator.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/asio.hpp            |     1 +                                       
   trunk/libs/asio/test/Jamfile    |     1 +                                       
   trunk/libs/asio/test/Jamfile.v2 |     2 ++                                      
   3 files changed, 4 insertions(+), 0 deletions(-)

Modified: trunk/boost/asio.hpp
==============================================================================
--- trunk/boost/asio.hpp	(original)
+++ trunk/boost/asio.hpp	2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
@@ -34,6 +34,7 @@
 #include <boost/asio/buffered_stream.hpp>
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 #include <boost/asio/buffered_write_stream.hpp>
+#include <boost/asio/buffers_iterator.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/datagram_socket_service.hpp>
 #include <boost/asio/deadline_timer_service.hpp>

Added: trunk/boost/asio/buffers_iterator.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/asio/buffers_iterator.hpp	2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
@@ -0,0 +1,320 @@
+//
+// buffers_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERS_ITERATOR_HPP
+#define BOOST_ASIO_BUFFERS_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail
+{
+  template <bool IsMutable>
+  struct buffers_iterator_types_helper;
+
+  template <>
+  struct buffers_iterator_types_helper<false>
+  {
+    typedef const_buffer buffer_type;
+    template <typename ByteType>
+    struct byte_type
+    {
+      typedef typename boost::add_const<ByteType>::type type;
+    };
+  };
+
+  template <>
+  struct buffers_iterator_types_helper<true>
+  {
+    typedef mutable_buffer buffer_type;
+    template <typename ByteType>
+    struct byte_type
+    {
+      typedef ByteType type;
+    };
+  };
+
+  template <typename BufferSequence, typename ByteType>
+  struct buffers_iterator_types
+  {
+    enum
+    {
+      is_mutable = boost::is_convertible<
+        typename BufferSequence::value_type, mutable_buffer>::value
+    };
+    typedef buffers_iterator_types_helper<is_mutable> helper;
+    typedef typename helper::buffer_type buffer_type;
+    typedef typename helper::template byte_type<ByteType>::type byte_type;
+  };
+}
+
+/// A random access iterator over the bytes in a buffer sequence.
+template <typename BufferSequence, typename ByteType = char>
+class buffers_iterator
+  : public boost::iterator_facade<
+        buffers_iterator<BufferSequence, ByteType>,
+        typename detail::buffers_iterator_types<
+          BufferSequence, ByteType>::byte_type,
+        boost::random_access_traversal_tag>
+{
+private:
+  typedef typename detail::buffers_iterator_types<
+      BufferSequence, ByteType>::buffer_type buffer_type;
+  typedef typename detail::buffers_iterator_types<
+      BufferSequence, ByteType>::byte_type byte_type;
+
+public:
+  /// Default constructor. Creates an iterator in an undefined state.
+  buffers_iterator()
+    : current_buffer_(),
+      current_buffer_position_(0),
+      begin_(),
+      current_(),
+      end_(),
+      position_(0)
+  {
+  }
+
+  /// Construct an iterator representing the beginning of the buffers' data.
+  static buffers_iterator begin(const BufferSequence& buffers)
+  {
+    buffers_iterator new_iter;
+    new_iter.begin_ = buffers.begin();
+    new_iter.current_ = buffers.begin();
+    new_iter.end_ = buffers.end();
+    while (new_iter.current_ != new_iter.end_)
+    {
+      new_iter.current_buffer_ = *new_iter.current_;
+      if (boost::asio::buffer_size(new_iter.current_buffer_) > 0)
+        break;
+      ++new_iter.current_;
+    }
+    return new_iter;
+  }
+
+  /// Construct an iterator representing the end of the buffers' data.
+  static buffers_iterator end(const BufferSequence& buffers)
+  {
+    buffers_iterator new_iter;
+    new_iter.begin_ = buffers.begin();
+    new_iter.current_ = buffers.begin();
+    new_iter.end_ = buffers.end();
+    while (new_iter.current_ != new_iter.end_)
+    {
+      buffer_type buffer = *new_iter.current_;
+      new_iter.position_ += boost::asio::buffer_size(buffer);
+      ++new_iter.current_;
+    }
+    return new_iter;
+  }
+
+private:
+  friend class boost::iterator_core_access;
+
+  // Dereference the iterator.
+  byte_type& dereference() const
+  {
+    return buffer_cast<byte_type*>(current_buffer_)[current_buffer_position_];
+  }
+
+  // Compare two iterators for equality.
+  bool equal(const buffers_iterator& other) const
+  {
+    return position_ == other.position_;
+  }
+
+  // Increment the iterator.
+  void increment()
+  {
+    BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
+    ++position_;
+
+    // Check if the increment can be satisfied by the current buffer.
+    ++current_buffer_position_;
+    if (current_buffer_position_ != boost::asio::buffer_size(current_buffer_))
+      return;
+
+    // Find the next non-empty buffer.
+    ++current_;
+    current_buffer_position_ = 0;
+    while (current_ != end_)
+    {
+      current_buffer_ = *current_;
+      if (boost::asio::buffer_size(current_buffer_) > 0)
+        return;
+      ++current_;
+    }
+  }
+
+  // Decrement the iterator.
+  void decrement()
+  {
+    BOOST_ASSERT(position_ > 0 && "iterator out of bounds");
+    --position_;
+
+    // Check if the decrement can be satisfied by the current buffer.
+    if (current_buffer_position_ != 0)
+    {
+      --current_buffer_position_;
+      return;
+    }
+
+    // Find the previous non-empty buffer.
+    typename BufferSequence::const_iterator iter = current_;
+    while (iter != begin_)
+    {
+      --iter;
+      buffer_type buffer = *iter;
+      std::size_t buffer_size = boost::asio::buffer_size(buffer);
+      if (buffer_size > 0)
+      {
+        current_ = iter;
+        current_buffer_ = buffer;
+        current_buffer_position_ = buffer_size - 1;
+        return;
+      }
+    }
+  }
+
+  // Advance the iterator by the specified distance.
+  void advance(std::ptrdiff_t n)
+  {
+    if (n > 0)
+    {
+      BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
+      for (;;)
+      {
+        std::ptrdiff_t current_buffer_balance
+          = boost::asio::buffer_size(current_buffer_)
+          - current_buffer_position_;
+
+        // Check if the advance can be satisfied by the current buffer.
+        if (current_buffer_balance > n)
+        {
+          position_ += n;
+          current_buffer_position_ += n;
+          return;
+        }
+
+        // Update position.
+        n -= current_buffer_balance;
+        position_ += current_buffer_balance;
+
+        // Move to next buffer. If it is empty then it will be skipped on the
+        // next iteration of this loop.
+        if (++current_ == end_)
+        {
+          BOOST_ASSERT(n == 0 && "iterator out of bounds");
+          current_buffer_ = buffer_type();
+          current_buffer_position_ = 0;
+          return;
+        }
+        current_buffer_ = *current_;
+        current_buffer_position_ = 0;
+      }
+    }
+    else if (n < 0)
+    {
+      std::size_t abs_n = -n;
+      BOOST_ASSERT(position_ >= abs_n && "iterator out of bounds");
+      for (;;)
+      {
+        // Check if the advance can be satisfied by the current buffer.
+        if (current_buffer_position_ >= abs_n)
+        {
+          position_ -= abs_n;
+          current_buffer_position_ -= abs_n;
+          return;
+        }
+
+        // Update position.
+        abs_n -= current_buffer_position_;
+        position_ -= current_buffer_position_;
+
+        // Check if we've reached the beginning of the buffers.
+        if (current_ == begin_)
+        {
+          BOOST_ASSERT(abs_n == 0 && "iterator out of bounds");
+          current_buffer_position_ = 0;
+          return;
+        }
+
+        // Find the previous non-empty buffer.
+        typename BufferSequence::const_iterator iter = current_;
+        while (iter != begin_)
+        {
+          --iter;
+          buffer_type buffer = *iter;
+          std::size_t buffer_size = boost::asio::buffer_size(buffer);
+          if (buffer_size > 0)
+          {
+            current_ = iter;
+            current_buffer_ = buffer;
+            current_buffer_position_ = buffer_size;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Determine the distance between two iterators.
+  std::ptrdiff_t distance_to(const buffers_iterator& other) const
+  {
+    return other.position_ - position_;
+  }
+
+  buffer_type current_buffer_;
+  std::size_t current_buffer_position_;
+  typename BufferSequence::const_iterator begin_;
+  typename BufferSequence::const_iterator current_;
+  typename BufferSequence::const_iterator end_;
+  std::size_t position_;
+};
+
+/// Construct an iterator representing the beginning of the buffers' data.
+template <typename BufferSequence>
+inline buffers_iterator<BufferSequence> buffers_begin(
+    const BufferSequence& buffers)
+{
+  return buffers_iterator<BufferSequence>::begin(buffers);
+}
+
+/// Construct an iterator representing the end of the buffers' data.
+template <typename BufferSequence>
+inline buffers_iterator<BufferSequence> buffers_end(
+    const BufferSequence& buffers)
+{
+  return buffers_iterator<BufferSequence>::end(buffers);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERS_ITERATOR_HPP

Modified: trunk/libs/asio/test/Jamfile
==============================================================================
--- trunk/libs/asio/test/Jamfile	(original)
+++ trunk/libs/asio/test/Jamfile	2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
@@ -45,6 +45,7 @@
   [ run buffered_read_stream.cpp <template>asio_unit_test ]
   [ run buffered_stream.cpp <template>asio_unit_test ]
   [ run buffered_write_stream.cpp <template>asio_unit_test ]
+  [ run buffers_iterator.cpp <template>asio_unit_test ]
   [ run completion_condition.cpp <template>asio_unit_test ]
   [ run datagram_socket_service.cpp <template>asio_unit_test ]
   [ run deadline_timer_service.cpp <template>asio_unit_test ]

Modified: trunk/libs/asio/test/Jamfile.v2
==============================================================================
--- trunk/libs/asio/test/Jamfile.v2	(original)
+++ trunk/libs/asio/test/Jamfile.v2	2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
@@ -68,6 +68,8 @@
   [ run buffered_stream.cpp : : : $(USE_SELECT) : buffered_stream_select ]
   [ run buffered_write_stream.cpp ]
   [ run buffered_write_stream.cpp : : : $(USE_SELECT) : buffered_write_stream_select ]
+  [ run buffers_iterator.cpp ]
+  [ run buffers_iterator.cpp : : : $(USE_SELECT) : buffers_iterator_select ]
   [ link completion_condition.cpp ]
   [ link completion_condition.cpp : $(USE_SELECT) : completion_condition_select ]
   [ link datagram_socket_service.cpp ]

Added: trunk/libs/asio/test/buffers_iterator.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/asio/test/buffers_iterator.cpp	2008-06-15 20:41:29 EDT (Sun, 15 Jun 2008)
@@ -0,0 +1,230 @@
+//
+// buffers_iterator.cpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2008 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)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/buffers_iterator.hpp>
+
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// buffers_iterator_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all operations on the buffers_iterator compile
+// and link correctly. Runtime failures are ignored.
+
+namespace buffers_iterator_compile {
+
+using boost::array;
+using std::vector;
+using namespace boost::asio;
+
+void test()
+{
+  try
+  {
+    char data1[16], data2[16];
+    const char cdata1[16] = "", cdata2[16] = "";
+    mutable_buffers_1 mb1 = buffer(data1);
+    array<mutable_buffer, 2> mb2 = {{ buffer(data1), buffer(data2) }};
+    std::vector<mutable_buffer> mb3;
+    mb3.push_back(buffer(data1));
+    const_buffers_1 cb1 = buffer(cdata1);
+    array<const_buffer, 2> cb2 = {{ buffer(cdata1), buffer(cdata2) }};
+    vector<const_buffer> cb3;
+    cb3.push_back(buffer(cdata1));
+
+
+    // buffers_iterator constructors.
+
+    buffers_iterator<mutable_buffers_1, char> bi1;
+    buffers_iterator<mutable_buffers_1, const char> bi2;
+    buffers_iterator<array<mutable_buffer, 2>, char> bi3;
+    buffers_iterator<array<mutable_buffer, 2>, const char> bi4;
+    buffers_iterator<vector<mutable_buffer>, char> bi5;
+    buffers_iterator<vector<mutable_buffer>, const char> bi6;
+    buffers_iterator<const_buffers_1, char> bi7;
+    buffers_iterator<const_buffers_1, const char> bi8;
+    buffers_iterator<array<const_buffer, 2>, char> bi9;
+    buffers_iterator<array<const_buffer, 2>, const char> bi10;
+    buffers_iterator<vector<const_buffer>, char> bi11;
+    buffers_iterator<vector<const_buffer>, const char> bi12;
+
+    buffers_iterator<mutable_buffers_1, char> bi13(bi1);
+    buffers_iterator<mutable_buffers_1, const char> bi14(bi2);
+    buffers_iterator<array<mutable_buffer, 2>, char> bi15(bi3);
+    buffers_iterator<array<mutable_buffer, 2>, const char> bi16(bi4);
+    buffers_iterator<vector<mutable_buffer>, char> bi17(bi5);
+    buffers_iterator<vector<mutable_buffer>, const char> bi18(bi6);
+    buffers_iterator<const_buffers_1, char> bi19(bi7);
+    buffers_iterator<const_buffers_1, const char> bi20(bi8);
+    buffers_iterator<array<const_buffer, 2>, char> bi21(bi9);
+    buffers_iterator<array<const_buffer, 2>, const char> bi22(bi10);
+    buffers_iterator<vector<const_buffer>, char> bi23(bi11);
+    buffers_iterator<vector<const_buffer>, const char> bi24(bi12);
+
+    // buffers_iterator member functions.
+
+    bi1 = buffers_iterator<mutable_buffers_1, char>::begin(mb1);
+    bi2 = buffers_iterator<mutable_buffers_1, const char>::begin(mb1);
+    bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::begin(mb2);
+    bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::begin(mb2);
+    bi5 = buffers_iterator<vector<mutable_buffer>, char>::begin(mb3);
+    bi6 = buffers_iterator<vector<mutable_buffer>, const char>::begin(mb3);
+    bi7 = buffers_iterator<const_buffers_1, char>::begin(cb1);
+    bi8 = buffers_iterator<const_buffers_1, const char>::begin(cb1);
+    bi9 = buffers_iterator<array<const_buffer, 2>, char>::begin(cb2);
+    bi10 = buffers_iterator<array<const_buffer, 2>, const char>::begin(cb2);
+    bi11 = buffers_iterator<vector<const_buffer>, char>::begin(cb3);
+    bi12 = buffers_iterator<vector<const_buffer>, const char>::begin(cb3);
+
+    bi1 = buffers_iterator<mutable_buffers_1, char>::end(mb1);
+    bi2 = buffers_iterator<mutable_buffers_1, const char>::end(mb1);
+    bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::end(mb2);
+    bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::end(mb2);
+    bi5 = buffers_iterator<vector<mutable_buffer>, char>::end(mb3);
+    bi6 = buffers_iterator<vector<mutable_buffer>, const char>::end(mb3);
+    bi7 = buffers_iterator<const_buffers_1, char>::end(cb1);
+    bi8 = buffers_iterator<const_buffers_1, const char>::end(cb1);
+    bi9 = buffers_iterator<array<const_buffer, 2>, char>::end(cb2);
+    bi10 = buffers_iterator<array<const_buffer, 2>, const char>::end(cb2);
+    bi11 = buffers_iterator<vector<const_buffer>, char>::end(cb3);
+    bi12 = buffers_iterator<vector<const_buffer>, const char>::end(cb3);
+
+    // buffers_iterator related functions.
+
+    bi1 = buffers_begin(mb1);
+    bi3 = buffers_begin(mb2);
+    bi5 = buffers_begin(mb3);
+    bi7 = buffers_begin(cb1);
+    bi9 = buffers_begin(cb2);
+    bi11 = buffers_begin(cb3);
+
+    bi1 = buffers_end(mb1);
+    bi3 = buffers_end(mb2);
+    bi5 = buffers_end(mb3);
+    bi7 = buffers_end(cb1);
+    bi9 = buffers_end(cb2);
+    bi11 = buffers_end(cb3);
+
+    // RandomAccessIterator operations.
+
+    --bi1;
+    --bi2;
+    --bi3;
+    --bi4;
+    --bi5;
+    --bi6;
+    --bi7;
+    --bi8;
+    --bi9;
+    --bi10;
+    --bi11;
+    --bi12;
+
+    ++bi1;
+    ++bi2;
+    ++bi3;
+    ++bi4;
+    ++bi5;
+    ++bi6;
+    ++bi7;
+    ++bi8;
+    ++bi9;
+    ++bi10;
+    ++bi11;
+    ++bi12;
+
+    bi1--;
+    bi2--;
+    bi3--;
+    bi4--;
+    bi5--;
+    bi6--;
+    bi7--;
+    bi8--;
+    bi9--;
+    bi10--;
+    bi11--;
+    bi12--;
+
+    bi1++;
+    bi2++;
+    bi3++;
+    bi4++;
+    bi5++;
+    bi6++;
+    bi7++;
+    bi8++;
+    bi9++;
+    bi10++;
+    bi11++;
+    bi12++;
+
+    bi1 -= 1;
+    bi2 -= 1;
+    bi3 -= 1;
+    bi4 -= 1;
+    bi5 -= 1;
+    bi6 -= 1;
+    bi7 -= 1;
+    bi8 -= 1;
+    bi9 -= 1;
+    bi10 -= 1;
+    bi11 -= 1;
+    bi12 -= 1;
+
+    bi1 += 1;
+    bi2 += 1;
+    bi3 += 1;
+    bi4 += 1;
+    bi5 += 1;
+    bi6 += 1;
+    bi7 += 1;
+    bi8 += 1;
+    bi9 += 1;
+    bi10 += 1;
+    bi11 += 1;
+    bi12 += 1;
+
+    static_cast<std::ptrdiff_t>(bi13 - bi1);
+    static_cast<std::ptrdiff_t>(bi14 - bi2);
+    static_cast<std::ptrdiff_t>(bi15 - bi3);
+    static_cast<std::ptrdiff_t>(bi16 - bi4);
+    static_cast<std::ptrdiff_t>(bi17 - bi5);
+    static_cast<std::ptrdiff_t>(bi18 - bi6);
+    static_cast<std::ptrdiff_t>(bi19 - bi7);
+    static_cast<std::ptrdiff_t>(bi20 - bi8);
+    static_cast<std::ptrdiff_t>(bi21 - bi9);
+    static_cast<std::ptrdiff_t>(bi22 - bi10);
+    static_cast<std::ptrdiff_t>(bi23 - bi11);
+    static_cast<std::ptrdiff_t>(bi24 - bi12);
+  }
+  catch (std::exception&)
+  {
+  }
+}
+
+} // namespace buffers_iterator_compile
+
+//------------------------------------------------------------------------------
+
+test_suite* init_unit_test_suite(int, char*[])
+{
+  test_suite* test = BOOST_TEST_SUITE("buffers_iterator");
+  test->add(BOOST_TEST_CASE(&buffers_iterator_compile::test));
+  return test;
+}