Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r57161 - in trunk: boost/circular_buffer libs/circular_buffer/doc libs/circular_buffer/test
From: jano_gaspar_at_[hidden]
Date: 2009-10-26 17:37:02


Author: jano_gaspar
Date: 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
New Revision: 57161
URL: http://svn.boost.org/trac/boost/changeset/57161

Log:
circular_buffer: added erase_begin and erase_end methods
Added:
   trunk/libs/circular_buffer/test/erase_begin_end.cpp (contents, props changed)
Text files modified:
   trunk/boost/circular_buffer/base.hpp | 102 +++++++++++++++
   trunk/boost/circular_buffer/space_optimized.hpp | 6
   trunk/libs/circular_buffer/doc/circular_buffer.html | 247 +++++++++++++++++++++++++++++++++++++++
   trunk/libs/circular_buffer/doc/space_optimized.xslt | 4
   trunk/libs/circular_buffer/test/Jamfile.v2 | 1
   5 files changed, 349 insertions(+), 11 deletions(-)

Modified: trunk/boost/circular_buffer/base.hpp
==============================================================================
--- trunk/boost/circular_buffer/base.hpp (original)
+++ trunk/boost/circular_buffer/base.hpp 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -20,6 +20,7 @@
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/type_traits/is_stateless.hpp>
 #include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_scalar.hpp>
 #include <algorithm>
 #include <utility>
 #include <deque>
@@ -1805,7 +1806,8 @@
         \par Complexity
              Linear (in <code>std::distance(pos, end())</code>).
         \sa <code>erase(iterator, iterator)</code>, <code>rerase(iterator)</code>,
- <code>rerase(iterator, iterator)</code>, <code>clear()</code>
+ <code>rerase(iterator, iterator)</code>, <code>erase_begin(size_type)</code>,
+ <code>erase_end(size_type)</code>, <code>clear()</code>
     */
     iterator erase(iterator pos) {
         BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -1842,7 +1844,7 @@
         \par Complexity
              Linear (in <code>std::distance(first, end())</code>).
         \sa <code>erase(iterator)</code>, <code>rerase(iterator)</code>, <code>rerase(iterator, iterator)</code>,
- <code>clear()</code>
+ <code>erase_begin(size_type)</code>, <code>erase_end(size_type)</code>, <code>clear()</code>
     */
     iterator erase(iterator first, iterator last) {
         BOOST_CB_ASSERT(first.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -1881,7 +1883,8 @@
               <code>erase(iterator)</code> if the iterator <code>pos</code> is close to the beginning of the
               <code>circular_buffer</code>. (See the <i>Complexity</i>.)
         \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>,
- <code>rerase(iterator, iterator)</code>, <code>clear()</code>
+ <code>rerase(iterator, iterator)</code>, <code>erase_begin(size_type)</code>,
+ <code>erase_end(size_type)</code>, <code>clear()</code>
     */
     iterator rerase(iterator pos) {
         BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -1921,7 +1924,7 @@
               <code>erase(iterator, iterator)</code> if <code>std::distance(begin(), first)</code> is lower that
               <code>std::distance(last, end())</code>.
         \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>, <code>rerase(iterator)</code>,
- <code>clear()</code>
+ <code>erase_begin(size_type)</code>, <code>erase_end(size_type)</code>, <code>clear()</code>
     */
     iterator rerase(iterator first, iterator last) {
         BOOST_CB_ASSERT(first.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -1947,6 +1950,70 @@
         return iterator(this, last.m_it);
     }
 
+ //! Remove first <code>n</code> elements (with constant complexity for scalar types).
+ /*!
+ \pre <code>n \<= size()</code>
+ \post The <code>n</code> elements at the beginning of the <code>circular_buffer</code> will be removed.
+ \param n The number of elements to be removed.
+ \throws Whatever <code>T::operator = (const T&)</code> throws. (Does not throw anything in case of scalars.)
+ \par Exception Safety
+ Basic; no-throw if the operation in the <i>Throws</i> section does not throw anything. (I.e. no throw in
+ case of scalars.)
+ \par Iterator Invalidation
+ Invalidates iterators pointing to the first <code>n</code> erased elements.
+ \par Complexity
+ Constant (in <code>n</code>) for scalar types; linear for other types.
+ \note This method has been specially designed for types which do not require an explicit destructruction (e.g.
+ integer, float or a pointer). For these scalar types a call to a destructor is not required which makes
+ it possible to implement the "erase from beginning" operation with a constant complexity. For non-sacalar
+ types the complexity is linear (hence the explicit destruction is needed) and the implementation is
+ actually equivalent to
+ <code>\link circular_buffer::rerase(iterator, iterator) rerase(begin(), begin() + n)\endlink</code>.
+ \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>,
+ <code>rerase(iterator)</code>, <code>rerase(iterator, iterator)</code>,
+ <code>erase_end(size_type)</code>, <code>clear()</code>
+ */
+ void erase_begin(size_type n) {
+ BOOST_CB_ASSERT(n <= size()); // check for n greater than size
+#if BOOST_CB_ENABLE_DEBUG
+ erase_begin(n, false_type());
+#else
+ erase_begin(n, is_scalar<value_type>());
+#endif
+ }
+
+ //! Remove last <code>n</code> elements (with constant complexity for scalar types).
+ /*!
+ \pre <code>n \<= size()</code>
+ \post The <code>n</code> elements at the end of the <code>circular_buffer</code> will be removed.
+ \param n The number of elements to be removed.
+ \throws Whatever <code>T::operator = (const T&)</code> throws. (Does not throw anything in case of scalars.)
+ \par Exception Safety
+ Basic; no-throw if the operation in the <i>Throws</i> section does not throw anything. (I.e. no throw in
+ case of scalars.)
+ \par Iterator Invalidation
+ Invalidates iterators pointing to the last <code>n</code> erased elements.
+ \par Complexity
+ Constant (in <code>n</code>) for scalar types; linear for other types.
+ \note This method has been specially designed for types which do not require an explicit destructruction (e.g.
+ integer, float or a pointer). For these scalar types a call to a destructor is not required which makes
+ it possible to implement the "erase from end" operation with a constant complexity. For non-sacalar
+ types the complexity is linear (hence the explicit destruction is needed) and the implementation is
+ actually equivalent to
+ <code>\link circular_buffer::erase(iterator, iterator) erase(end() - n, end())\endlink</code>.
+ \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>,
+ <code>rerase(iterator)</code>, <code>rerase(iterator, iterator)</code>,
+ <code>erase_begin(size_type)</code>, <code>clear()</code>
+ */
+ void erase_end(size_type n) {
+ BOOST_CB_ASSERT(n <= size()); // check for n greater than size
+#if BOOST_CB_ENABLE_DEBUG
+ erase_end(n, false_type());
+#else
+ erase_end(n, is_scalar<value_type>());
+#endif
+ }
+
     //! Remove all stored elements from the <code>circular_buffer</code>.
     /*!
         \post <code>size() == 0</code>
@@ -1959,7 +2026,8 @@
         \par Complexity
              Linear (in the size of the <code>circular_buffer</code>).
         \sa <code>~circular_buffer()</code>, <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>,
- <code>rerase(iterator)</code>, <code>rerase(iterator, iterator)</code>
+ <code>rerase(iterator)</code>, <code>rerase(iterator, iterator)</code>,
+ <code>erase_begin(size_type)</code>, <code>erase_end(size_type)</code>
     */
     void clear() {
         destroy_content();
@@ -2564,6 +2632,30 @@
         m_last = sub(m_last, n - construct);
         m_size += construct;
     }
+
+ //! Specialized erase_begin method.
+ void erase_begin(size_type n, const true_type&) {
+ m_first = add(m_first, n);
+ m_size -= n;
+ }
+
+ //! Specialized erase_begin method.
+ void erase_begin(size_type n, const false_type&) {
+ iterator b = begin();
+ rerase(b, b + n);
+ }
+
+ //! Specialized erase_end method.
+ void erase_end(size_type n, const true_type&) {
+ m_last = sub(m_last, n);
+ m_size -= n;
+ }
+
+ //! Specialized erase_end method.
+ void erase_end(size_type n, const false_type&) {
+ iterator e = end();
+ erase(e - n, e);
+ }
 };
 
 // Non-member functions

Modified: trunk/boost/circular_buffer/space_optimized.hpp
==============================================================================
--- trunk/boost/circular_buffer/space_optimized.hpp (original)
+++ trunk/boost/circular_buffer/space_optimized.hpp 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -513,6 +513,12 @@
     */
     ~circular_buffer_space_optimized();
 
+ //! no-comment
+ void erase_begin(size_type n);
+
+ //! no-comment
+ void erase_end(size_type n);
+
 #endif // #if defined(BOOST_CB_NEVER_DEFINED)
 
     //! The assign operator.

Modified: trunk/libs/circular_buffer/doc/circular_buffer.html
==============================================================================
--- trunk/libs/circular_buffer/doc/circular_buffer.html (original)
+++ trunk/libs/circular_buffer/doc/circular_buffer.html 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -338,6 +338,8 @@
    iterator rerase(iterator pos);
    iterator <a href=
 "#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase</a>(iterator first, iterator last);
+ void erase_begin(size_type n);
+ void erase_end(size_type n);
    void clear();
 };
 
@@ -6110,7 +6112,10 @@
                 "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
                 <code><a href="#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
                 iterator)</a></code>, <code><a href=
- "#classboost_1_1circular__buffer_1826f5770a40b8b752eb9587378464d1e">clear()</a></code>
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>,
+ <code>clear()</code>
               </dd>
             </dl>
           </td>
@@ -6222,7 +6227,10 @@
                 "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
                 <code><a href="#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
                 iterator)</a></code>, <code><a href=
- "#classboost_1_1circular__buffer_1826f5770a40b8b752eb9587378464d1e">clear()</a></code>
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>,
+ <code>clear()</code>
               </dd>
             </dl>
           </td>
@@ -6335,7 +6343,10 @@
                 iterator)</a></code>, <code><a href=
                 "#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
                 iterator)</a></code>, <code><a href=
- "#classboost_1_1circular__buffer_1826f5770a40b8b752eb9587378464d1e">clear()</a></code>
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>,
+ <code>clear()</code>
               </dd>
             </dl>
           </td>
@@ -6460,6 +6471,219 @@
                 <code><a href="#classboost_1_1circular__buffer_1a96415389509a18bd7d7b5d8e4dda9bd">erase(iterator,
                 iterator)</a></code>, <code><a href=
                 "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>,
+ <code>clear()</code>
+ </dd>
+ </dl>
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <a id="classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd" name=
+ "classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd"></a><code><b>void erase_begin(<a href=
+ "#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n);</b></code><br>
+ <br>
+ Remove first <code>n</code> elements (with constant complexity for scalar types).
+ <dl>
+ <dt>
+ <b>Precondition:</b>
+ </dt>
+ <dd>
+ <code>n &lt;= <a href=
+ "#classboost_1_1circular__buffer_15fa0edd153e2591dd6bf070eb663ee32">size()</a></code>
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Effect:</b>
+ </dt>
+ <dd>
+ The <code>n</code> elements at the beginning of the <code>circular_buffer</code> will be removed.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Parameter(s):</b>
+ </dt>
+ <dd>
+ <dl compact>
+ <dt>
+ <code>n</code>
+ </dt>
+ <dd>
+ The number of elements to be removed.
+ </dd>
+ </dl>
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Throws:</b>
+ </dt>
+ <dd>
+ Whatever <code>T::operator = (const T&amp;)</code> throws. (Does not throw anything in case of
+ scalars.)
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Exception Safety:</b>
+ </dt>
+ <dd>
+ Basic; no-throw if the operation in the <i>Throws</i> section does not throw anything. (I.e. no throw
+ in case of scalars.)
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Iterator Invalidation:</b>
+ </dt>
+ <dd>
+ Invalidates iterators pointing to the first <code>n</code> erased elements.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Complexity:</b>
+ </dt>
+ <dd>
+ Constant (in <code>n</code>) for scalar types; linear for other types.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Note:</b>
+ </dt>
+ <dd>
+ This method has been specially designed for types which do not require an explicit destructruction
+ (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which
+ makes it possible to implement the "erase from beginning" operation with a constant complexity. For
+ non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the
+ implementation is actually equivalent to <code><a href=
+ "#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(begin(), begin() +
+ n)</a></code>.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>See Also:</b>
+ </dt>
+ <dd>
+ <code><a href=
+ "#classboost_1_1circular__buffer_197155de712db1759e1698455b49a0be3">erase(iterator)</a></code>,
+ <code><a href="#classboost_1_1circular__buffer_1a96415389509a18bd7d7b5d8e4dda9bd">erase(iterator,
+ iterator)</a></code>, <code><a href=
+ "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
+ <code><a href="#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
+ iterator)</a></code>, <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>,
+ <code>clear()</code>
+ </dd>
+ </dl>
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <a id="classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7" name=
+ "classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7"></a><code><b>void erase_end(<a href=
+ "#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n);</b></code><br>
+ <br>
+ Remove last <code>n</code> elements (with constant complexity for scalar types).
+ <dl>
+ <dt>
+ <b>Precondition:</b>
+ </dt>
+ <dd>
+ <code>n &lt;= <a href=
+ "#classboost_1_1circular__buffer_15fa0edd153e2591dd6bf070eb663ee32">size()</a></code>
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Effect:</b>
+ </dt>
+ <dd>
+ The <code>n</code> elements at the end of the <code>circular_buffer</code> will be removed.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Parameter(s):</b>
+ </dt>
+ <dd>
+ <dl compact>
+ <dt>
+ <code>n</code>
+ </dt>
+ <dd>
+ The number of elements to be removed.
+ </dd>
+ </dl>
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Throws:</b>
+ </dt>
+ <dd>
+ Whatever <code>T::operator = (const T&amp;)</code> throws. (Does not throw anything in case of
+ scalars.)
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Exception Safety:</b>
+ </dt>
+ <dd>
+ Basic; no-throw if the operation in the <i>Throws</i> section does not throw anything. (I.e. no throw
+ in case of scalars.)
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Iterator Invalidation:</b>
+ </dt>
+ <dd>
+ Invalidates iterators pointing to the last <code>n</code> erased elements.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Complexity:</b>
+ </dt>
+ <dd>
+ Constant (in <code>n</code>) for scalar types; linear for other types.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>Note:</b>
+ </dt>
+ <dd>
+ This method has been specially designed for types which do not require an explicit destructruction
+ (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which
+ makes it possible to implement the "erase from end" operation with a constant complexity. For
+ non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the
+ implementation is actually equivalent to <code><a href=
+ "#classboost_1_1circular__buffer_1a96415389509a18bd7d7b5d8e4dda9bd">erase(end() - n, end())</a></code>.
+ </dd>
+ </dl>
+ <dl>
+ <dt>
+ <b>See Also:</b>
+ </dt>
+ <dd>
+ <code><a href=
+ "#classboost_1_1circular__buffer_197155de712db1759e1698455b49a0be3">erase(iterator)</a></code>,
+ <code><a href="#classboost_1_1circular__buffer_1a96415389509a18bd7d7b5d8e4dda9bd">erase(iterator,
+ iterator)</a></code>, <code><a href=
+ "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
+ <code><a href="#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
+ iterator)</a></code>, <code><a href=
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
                 <code>clear()</code>
               </dd>
             </dl>
@@ -6527,7 +6751,10 @@
                 iterator)</a></code>, <code><a href=
                 "#classboost_1_1circular__buffer_1b6d4ae77d7445f844e30e78592f1e06f">rerase(iterator)</a></code>,
                 <code><a href="#classboost_1_1circular__buffer_1b0f98ae303584ded5397f067bbfc911f">rerase(iterator,
- iterator)</a></code>
+ iterator)</a></code>, <code><a href=
+ "#classboost_1_1circular__buffer_1b25d379cf66ace025036a47ddb344abd">erase_begin(size_type)</a></code>,
+ <code><a href=
+ "#classboost_1_1circular__buffer_17485ee7f58b01363170114f2123a48d7">erase_end(size_type)</a></code>
               </dd>
             </dl>
           </td>
@@ -7125,6 +7352,18 @@
     <dl>
       <dd>
         <h3>
+ Boost 1.42
+ </h3>
+ </dd>
+ <dd>
+ <ul>
+ <li>Added methods <code>erase_begin(size_type)</code> and <code>erase_end(size_type)</code> with constant
+ complexity for such types of stored elements which do not need an explicit destruction.
+ </li>
+ </ul>
+ </dd>
+ <dd>
+ <h3>
           Boost 1.37
         </h3>
       </dd>

Modified: trunk/libs/circular_buffer/doc/space_optimized.xslt
==============================================================================
--- trunk/libs/circular_buffer/doc/space_optimized.xslt (original)
+++ trunk/libs/circular_buffer/doc/space_optimized.xslt 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -68,7 +68,7 @@
         </xsl:apply-templates>
       </xsl:if>
     </xsl:for-each>
- <xsl:for-each select="$current[string-length(normalize-space(briefdescription)) &gt; 0]">
+ <xsl:for-each select="$current[string-length(normalize-space(briefdescription)) &gt; 0 and normalize-space(briefdescription) != 'no-comment']">
       <xsl:apply-templates select="." mode="synopsis"/>
     </xsl:for-each>
   </xsl:template>
@@ -96,7 +96,7 @@
   </xsl:template>
 
   <xsl:template name="member-functions-details">
- <xsl:for-each select="sectiondef[@kind='public-func']/memberdef[type != '' and string-length(normalize-space(briefdescription)) &gt; 0]">
+ <xsl:for-each select="sectiondef[@kind='public-func']/memberdef[type != '' and string-length(normalize-space(briefdescription)) &gt; 0 and normalize-space(briefdescription) != 'no-comment']">
       <xsl:apply-templates select="." mode="description"/>
     </xsl:for-each>
   </xsl:template>

Modified: trunk/libs/circular_buffer/test/Jamfile.v2
==============================================================================
--- trunk/libs/circular_buffer/test/Jamfile.v2 (original)
+++ trunk/libs/circular_buffer/test/Jamfile.v2 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -25,5 +25,6 @@
   : [ run base_test.cpp : <threading>single : ]
     [ run space_optimized_test.cpp : <threading>single : ]
     [ run soft_iterator_invalidation.cpp : <threading>single : ]
+ [ run erase_begin_end.cpp : <threading>single : ]
     [ compile bounded_buffer_comparison.cpp : <threading>multi : ]
   ;

Added: trunk/libs/circular_buffer/test/erase_begin_end.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/circular_buffer/test/erase_begin_end.cpp 2009-10-26 17:37:01 EDT (Mon, 26 Oct 2009)
@@ -0,0 +1,131 @@
+// Tests for erase_begin and erase_end methods.
+
+// Copyright (c) 2009 Jan Gaspar
+
+// Use, modification, and distribution is subject to 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)
+
+#define BOOST_CB_DISABLE_DEBUG
+
+#include "test.hpp"
+
+int MyInteger::ms_exception_trigger = 0;
+int InstanceCounter::ms_count = 0;
+
+void erase_begin_test() {
+
+ circular_buffer<int> cb1(5);
+ cb1.push_back(1);
+ cb1.push_back(2);
+ cb1.push_back(3);
+ cb1.push_back(4);
+ cb1.push_back(5);
+ cb1.push_back(6);
+ cb1.erase_begin(2);
+
+ BOOST_CHECK(cb1.size() == 3);
+ BOOST_CHECK(cb1[0] == 4);
+ BOOST_CHECK(cb1[1] == 5);
+ BOOST_CHECK(cb1[2] == 6);
+
+ cb1.erase_begin(3);
+ BOOST_CHECK(cb1.empty());
+
+ cb1.push_back(10);
+ cb1.push_back(11);
+ cb1.push_back(12);
+
+ BOOST_CHECK(cb1.size() == 3);
+ BOOST_CHECK(cb1[0] == 10);
+ BOOST_CHECK(cb1[1] == 11);
+ BOOST_CHECK(cb1[2] == 12);
+
+ circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
+
+ BOOST_CHECK(cb2.size() == 5);
+ BOOST_CHECK(InstanceCounter::count() == 5);
+
+ cb2.erase_begin(2);
+
+ BOOST_CHECK(cb2.size() == 3);
+ BOOST_CHECK(InstanceCounter::count() == 3);
+
+ circular_buffer<MyInteger> cb3(5);
+ cb3.push_back(1);
+ cb3.push_back(2);
+ cb3.push_back(3);
+ cb3.push_back(4);
+ cb3.push_back(5);
+ cb3.push_back(6);
+ cb3.erase_begin(2);
+
+ BOOST_CHECK(cb3.size() == 3);
+ BOOST_CHECK(cb3[0] == 4);
+ BOOST_CHECK(cb3[1] == 5);
+ BOOST_CHECK(cb3[2] == 6);
+}
+
+void erase_end_test() {
+
+ circular_buffer<int> cb1(5);
+ cb1.push_back(1);
+ cb1.push_back(2);
+ cb1.push_back(3);
+ cb1.push_back(4);
+ cb1.push_back(5);
+ cb1.push_back(6);
+ cb1.erase_end(2);
+
+ BOOST_CHECK(cb1.size() == 3);
+ BOOST_CHECK(cb1[0] == 2);
+ BOOST_CHECK(cb1[1] == 3);
+ BOOST_CHECK(cb1[2] ==4);
+
+ cb1.erase_end(3);
+ BOOST_CHECK(cb1.empty());
+
+ cb1.push_back(10);
+ cb1.push_back(11);
+ cb1.push_back(12);
+
+ BOOST_CHECK(cb1.size() == 3);
+ BOOST_CHECK(cb1[0] == 10);
+ BOOST_CHECK(cb1[1] == 11);
+ BOOST_CHECK(cb1[2] == 12);
+
+ circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
+
+ BOOST_CHECK(cb2.size() == 5);
+ BOOST_CHECK(InstanceCounter::count() == 5);
+
+ cb2.erase_end(2);
+
+ BOOST_CHECK(cb2.size() == 3);
+ BOOST_CHECK(InstanceCounter::count() == 3);
+
+ circular_buffer<MyInteger> cb3(5);
+ cb3.push_back(1);
+ cb3.push_back(2);
+ cb3.push_back(3);
+ cb3.push_back(4);
+ cb3.push_back(5);
+ cb3.push_back(6);
+ cb3.erase_end(2);
+
+ BOOST_CHECK(cb3.size() == 3);
+ BOOST_CHECK(cb3[0] == 2);
+ BOOST_CHECK(cb3[1] == 3);
+ BOOST_CHECK(cb3[2] == 4);
+}
+
+// test main
+test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
+
+ test_suite* tests = BOOST_TEST_SUITE("Unit tests for erase_begin/erase_end methods of the circular_buffer.");
+
+ tests->add(BOOST_TEST_CASE(&erase_begin_test));
+ tests->add(BOOST_TEST_CASE(&erase_end_test));
+
+ return tests;
+}


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk