[Boost-commit] svn:boost r57161 - in trunk: boost/circular_buffer libs/circular_buffer/doc libs/circular_buffer/test

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;
+}