Files
circular_buffer/doc/space_optimized.html
Eric Niebler 13d864a7f3 Merged revisions 43679-43680,43685-43687,43690-43696,43701-43702,43704-43706,43709,43714-43715,43717-43719,43721-43723,43726,43730-43733,43735,43738-43739,43741-43742,43747-43748,43750,43752,43758,43766,43781-43782,43795,43799,43803-43804,43806-43809 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........
  r43679 | dgregor | 2008-03-17 10:31:21 -0700 (Mon, 17 Mar 2008) | 1 line
  
  Fix typo
........
  r43680 | dgregor | 2008-03-17 10:34:46 -0700 (Mon, 17 Mar 2008) | 1 line
  
  Fix some documentation issues. Fixes #1655, fixes #1660
........
  r43685 | eric_niebler | 2008-03-17 14:46:08 -0700 (Mon, 17 Mar 2008) | 1 line
  
  small interface simplification, doc comment improvements
........
  r43686 | jano_gaspar | 2008-03-17 15:27:15 -0700 (Mon, 17 Mar 2008) | 1 line
  
  circular_buffer: bugfix #1692
........
  r43687 | hljin | 2008-03-17 15:28:58 -0700 (Mon, 17 Mar 2008) | 1 line
  
  Added two scripts
........
  r43690 | ramey | 2008-03-17 21:58:51 -0700 (Mon, 17 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43691 | ramey | 2008-03-17 22:01:57 -0700 (Mon, 17 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43692 | ramey | 2008-03-17 22:47:10 -0700 (Mon, 17 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43693 | ramey | 2008-03-17 22:52:10 -0700 (Mon, 17 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43694 | ramey | 2008-03-17 22:53:07 -0700 (Mon, 17 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43695 | eric_niebler | 2008-03-17 23:18:33 -0700 (Mon, 17 Mar 2008) | 1 line
  
  work around gcc-4.0.1 bug with const-qualified function references
........
  r43696 | eric_niebler | 2008-03-17 23:44:45 -0700 (Mon, 17 Mar 2008) | 1 line
  
  better, restrict fix to gcc-4.0
........
  r43701 | ramey | 2008-03-18 08:51:13 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43702 | ramey | 2008-03-18 08:51:42 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43704 | ramey | 2008-03-18 09:31:36 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43705 | ramey | 2008-03-18 09:32:22 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43706 | ramey | 2008-03-18 09:32:48 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43709 | bemandawes | 2008-03-18 12:35:18 -0700 (Tue, 18 Mar 2008) | 1 line
  
  Fix inspect boo boos; mostly broken links
........
  r43714 | grafik | 2008-03-18 18:01:19 -0700 (Tue, 18 Mar 2008) | 1 line
  
  Disable serialization tests until Robert fixes the testing breakage.
........
  r43715 | bemandawes | 2008-03-18 18:42:03 -0700 (Tue, 18 Mar 2008) | 1 line
  
  Fix broken links
........
  r43717 | ramey | 2008-03-18 22:17:02 -0700 (Tue, 18 Mar 2008) | 3 lines
  
  Support serialization in DLLS
  Make thread-safe
  fix portable binary archives
........
  r43718 | eric_niebler | 2008-03-18 22:18:50 -0700 (Tue, 18 Mar 2008) | 1 line
  
  correct minor doc inaccuracies
........
  r43719 | jano_gaspar | 2008-03-19 02:24:24 -0700 (Wed, 19 Mar 2008) | 1 line
  
  circular_buffer: improved documentation
........
  r43721 | vladimir_prus | 2008-03-19 03:51:45 -0700 (Wed, 19 Mar 2008) | 5 lines
  
  Fix #1698 (http://svn.boost.org/trac/boost/ticket/1698).
  
      * build/virtual-target.jam (register): Ignore
      differences in incidental dependency features.
........
  r43722 | vladimir_prus | 2008-03-19 04:09:29 -0700 (Wed, 19 Mar 2008) | 3 lines
  
  Remove usage-requirements as they are not necessary,
  and can cause bogus dependencies for serialization's client.
........
  r43723 | bemandawes | 2008-03-19 05:33:41 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Fix ordering of libraries within categories. [Vicente Juan Botet]
........
  r43726 | grafik | 2008-03-19 09:27:43 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Re-enable serialization tests, now that they should be fixed.
........
  r43730 | anthonyw | 2008-03-19 10:25:13 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Removed some warnings: those from issue #1640 and others
........
  r43731 | danieljames | 2008-03-19 11:22:58 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Thread is now using quickbook so we have to add a dependency to get it to build, and add it to the path, as it needs to be picked up from the build location.
........
  r43732 | danieljames | 2008-03-19 11:27:34 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Remove 'using quickbook' from my documentation jamfiles. It is no longer necessary, and might be harmful.
........
  r43733 | pdimov | 2008-03-19 12:39:50 -0700 (Wed, 19 Mar 2008) | 1 line
  
  Regression test for enable_shared_from_this.
........
  r43735 | lbourdev | 2008-03-19 21:27:41 -0700 (Wed, 19 Mar 2008) | 3 lines
  
  GIL: Changed a private type name to differ from #define used on some Linux systems.
........
  r43738 | fmhess | 2008-03-20 12:32:43 -0700 (Thu, 20 Mar 2008) | 4 lines
  
  Added support for calling enable_shared_from_this::shared_from_this in
  constructors.  Closes #1696.
........
  r43739 | pdimov | 2008-03-20 15:10:52 -0700 (Thu, 20 Mar 2008) | 1 line
  
  Initialize _owned in the copy constructor as well.
........
  r43741 | lbourdev | 2008-03-21 02:40:59 -0700 (Fri, 21 Mar 2008) | 3 lines
  
  GIL: Fixed a bug in planar device_n view construction.
........
  r43742 | lbourdev | 2008-03-21 02:43:19 -0700 (Fri, 21 Mar 2008) | 3 lines
  
  GIL: Replaced tabs with spaces.
........
  r43747 | ramey | 2008-03-21 09:37:24 -0700 (Fri, 21 Mar 2008) | 1 line
  
  Added consideration for compac Tru64
........
  r43748 | ramey | 2008-03-21 09:40:06 -0700 (Fri, 21 Mar 2008) | 1 line
  
  added include <ostream> for friend operators
........
  r43750 | danieljames | 2008-03-21 09:52:40 -0700 (Fri, 21 Mar 2008) | 1 line
  
  Check links in single quotes as well as double quotes.
........
  r43752 | danieljames | 2008-03-21 09:56:35 -0700 (Fri, 21 Mar 2008) | 1 line
  
  Decode percent coded characters and '&amp;' when inspecting urls.
........
  r43758 | ramey | 2008-03-21 10:19:07 -0700 (Fri, 21 Mar 2008) | 1 line
  
  Adjustment to inhibit compile error with intel compilers
........
  r43766 | fmhess | 2008-03-21 12:19:25 -0700 (Fri, 21 Mar 2008) | 4 lines
  
  Worked around compilation error in boost::get_deleter when using old versions
  of g++.
........
  r43781 | noel_belcourt | 2008-03-21 14:04:36 -0700 (Fri, 21 Mar 2008) | 3 lines
  
  pgi-7.1 has testable version macros, yeah!
........
  r43782 | fmhess | 2008-03-21 14:12:21 -0700 (Fri, 21 Mar 2008) | 3 lines
  
  Fixed bogus test failure caused by new enable_shared_from_this features.
........
  r43795 | ramey | 2008-03-22 11:59:07 -0700 (Sat, 22 Mar 2008) | 4 lines
  
  streamlined Jamfile.v2
  eliminated build of binary_w*
  removed usage-requirement
  dropped serialization.jam as its no longer used
........
  r43799 | grafik | 2008-03-22 15:53:35 -0700 (Sat, 22 Mar 2008) | 1 line
  
  Remove svn exec property from files that should not be executable to fix permission problems in archives.
........
  r43803 | danieljames | 2008-03-23 06:03:24 -0700 (Sun, 23 Mar 2008) | 1 line
  
  Fix another license link I seem to have missed.
........
  r43804 | fmhess | 2008-03-23 07:51:40 -0700 (Sun, 23 Mar 2008) | 3 lines
  
  Added a little more test code for new enable_shared_from_this behavior.
........
  r43806 | ramey | 2008-03-23 11:36:00 -0700 (Sun, 23 Mar 2008) | 1 line
  
  adjusted header order for export.hpp to see if this will make gcc 4.x tests pass.
........
  r43807 | ramey | 2008-03-23 12:09:51 -0700 (Sun, 23 Mar 2008) | 1 line
  
  made test compile only
........
  r43808 | ramey | 2008-03-23 12:10:31 -0700 (Sun, 23 Mar 2008) | 1 line
  
  made test_static_warning compile only
........
  r43809 | ramey | 2008-03-23 12:18:22 -0700 (Sun, 23 Mar 2008) | 1 line
  
  removed superflous static cast
........


[SVN r43812]
2008-03-24 04:57:42 +00:00

4199 lines
173 KiB
HTML
Raw Blame History

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>
Space Optimized Circular Buffer
</title>
<link rel="stylesheet" href="../../../boost.css" type="text/css">
</head>
<body>
<h1>
Space Optimized Circular Buffer
</h1>
<table id="title" border="0">
<tr>
<td>
<h1>
circular_buffer_space_optimized&lt;T, Alloc&gt;
</h1>
</td>
<td>
<a href="../../../"><img src="../../../boost.png" width="277" height="86" alt="Boost" border="0"></a>
</td>
</tr>
</table>
<h2>
Contents
</h2><a href="#description">Description</a><br>
<a href="#synopsis">Synopsis</a><br>
<a href="#rationale">Rationale</a><br>
<a href="#header">Header Files</a><br>
<a href="#model">Modelled concepts</a><br>
<a href="#types">Specific Public Types</a><br>
<a href="#constructors">Constructors and Destructor</a><br>
<a href="#methods">Specific Public Member Functions</a><br>
<a href="#see">See also</a><br>
<a href="#ack">Acknowledgements</a>
<h2>
<a name="description" id="description">Description</a>
</h2>
<p>
The <code>circular_buffer_space_optimized</code> container is an adaptor of the <code><a href=
"circular_buffer.html">circular_buffer</a></code>. The functionality of the
<code>circular_buffer_space_optimized</code> is similar to the base <code>circular_buffer</code> except it does
not allocate memory at once when created rather it allocates memory as needed. (The predictive memory allocation
is similar to typical <code>std::vector</code> implementation.) Moreover the memory is automatically freed as the
size of the container decreases.
</p>
<table id="figure" border="0">
<tr>
<td></td>
<td>
<img src="space_optimized.png" width="700" height="350" alt="Space Optimized Circular Buffer" border="0">
</td>
</tr>
<tr>
<td valign="top">
<b>Figure:</b>
</td>
<td valign="top">
The memory allocation process of the space optimized circular buffer. The <code>min_capacity()</code> of the
<a href="#types">capacity controller</a> represents the minimal guaranteed amount of allocated memory. The
allocated memory will never drop under this value. The default value of the <code>min_capacity()</code> is
set to <code>0</code>.
</td>
</tr>
</table>
<h2>
<a name="synopsis" id="synopsis">Synopsis</a>
</h2>
<p>
Note that some of the links point to the original <code><a href="circular_buffer.html">circular_buffer</a></code>
if the functionality is the same.
</p>
<div id="srcdoc_synopsis">
<table id="table_synopsis" border="0" cellpadding="10">
<tr>
<td>
<pre>
namespace boost {
template &lt;class <a href="circular_buffer.html#templateparam_T">T</a>, class <a href=
"circular_buffer.html#templateparam_Alloc">Alloc</a>&gt;
class circular_buffer_space_optimized
{
public:
typedef typename Alloc::value_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1cbdd7ca87e147c08cd2be267eefd6540">value_type</a>;
typedef typename Alloc::pointer <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14ff917f8a6131ec18e91606727592a9c">pointer</a>;
typedef typename Alloc::const_pointer <a href=
"circular_buffer.html#classboost_1_1circular__buffer_190f7c6bcb624ad507de546366f49028a">const_pointer</a>;
typedef typename Alloc::reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1f38a9bc64d84757c661c2542ff9a7f65">reference</a>;
typedef typename Alloc::const_reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>;
typedef typename Alloc::size_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a>;
typedef typename Alloc::difference_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_15313e723fa85d73db5826f8b722aa2a9">difference_type</a>;
typedef Alloc <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>;
typedef <i>implementation-defined</i> <a href=
"circular_buffer.html#classboost_1_1circular__buffer_15cab6d46f03c40d1e52d41843319ddb9">const_iterator</a>;
typedef <i>implementation-defined</i> <a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>;
typedef boost::reverse_iterator&lt;const_iterator&gt; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1c7317701b511bc5f7a663b06b53e2b73">const_reverse_iterator</a>;
typedef boost::reverse_iterator&lt;iterator&gt; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1002fb890dded89e75dfeb6f021fb58a5">reverse_iterator</a>;
typedef std::pair&lt;pointer, size_type&gt; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_126d279f91fef717e25459a0817ff242f">array_range</a>;
typedef std::pair&lt;const_pointer, size_type&gt; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_11885d7f475b7e7a74c95b2448d243025">const_array_range</a>;
typedef <i>implementation-defined</i> <a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>;
explicit <a href=
"#classboost_1_1circular__buffer__space__optimized_1a05f824b31cd93d7695f4039edc7597f">circular_buffer_space_optimized</a>(const allocator_type&amp; alloc = allocator_type());
explicit <a href=
"#classboost_1_1circular__buffer__space__optimized_1741159a0511a4e0fed6eaab6d6959fa7">circular_buffer_space_optimized</a>(capacity_type capacity_ctrl, const allocator_type&amp; alloc = allocator_type());
<a href=
"#classboost_1_1circular__buffer__space__optimized_1f8c9fa872f9a84d454d7e245cc2eadbd">circular_buffer_space_optimized</a>(capacity_type capacity_ctrl, const_reference item, const allocator_type&amp; alloc = allocator_type());
<a href=
"#classboost_1_1circular__buffer__space__optimized_1d29ce80b10d4a3250fedeb9427210d96">circular_buffer_space_optimized</a>(capacity_type capacity_ctrl, size_type n, const_reference item, const allocator_type&amp; alloc = allocator_type());
<a href=
"#classboost_1_1circular__buffer__space__optimized_1d9f273c1a794f84484d220e977a3e24b">circular_buffer_space_optimized</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; cb);
template &lt;class InputIterator&gt;
<a href=
"#classboost_1_1circular__buffer__space__optimized_11dd04145492c82a959b1df1167b4e217">circular_buffer_space_optimized</a>(InputIterator first, InputIterator last, const allocator_type&amp; alloc = allocator_type());
template &lt;class InputIterator&gt;
<a href=
"#classboost_1_1circular__buffer__space__optimized_196c63e0ecd56f6f1ac87bc79d2fd5b9f">circular_buffer_space_optimized</a>(capacity_type capacity_ctrl, InputIterator first, InputIterator last, const allocator_type&amp; alloc = allocator_type());
<a href=
"#classboost_1_1circular__buffer__space__optimized_16839c3ea656ff0f800e38096748fe8ac">~circular_buffer_space_optimized</a>();
allocator_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_15693ba52e58ef90f1d914cbb63143cd3">get_allocator</a>() const;
allocator_type&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1af7758a36ac2f84a3024b50b4fc7e098">get_allocator</a>();
iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin</a>();
iterator <a href="circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end</a>();
const_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1ee6c38b2ecdc8dfec79975dbc685c80b">begin</a>() const;
const_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_19813e1d191cd04c4cfc100bbc4733e92">end</a>() const;
reverse_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1db3d6b10b6763549f54d2627228fa7aa">rbegin</a>();
reverse_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1cff9236a50107188b8942847a4dc2697">rend</a>();
const_reverse_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_146a8356a1aec6abca9c44cfc60b3bb10">rbegin</a>() const;
const_reverse_iterator <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a09f7111dde9f52a4d8babfcdef7e798">rend</a>() const;
reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d219f0d3203fb43b964a8cf63f1865cd">operator[]</a>(size_type index);
const_reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1eb0a7fe7f8a56a4dc4c933b93adfcef4">operator[]</a>(size_type index) const;
reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1cd84838cb4fffb6c113fd0297e502edc">at</a>(size_type index);
const_reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1b233a298f5845a0fcf2ecc56f4170810">at</a>(size_type index) const;
reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_10d5fdeabeb352f47d1f7bb1ea8d9819f">front</a>();
reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d985d974020f88bb4255d8edbae0a30a">back</a>();
const_reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_13261c47e81bb5e447fb0d70f096728b8">front</a>() const;
const_reference <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14cd3a019a9d99b4e29918b51c2181a07">back</a>() const;
array_range <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1957cccdcb0c4ef7d80a34a990065818d">array_one</a>();
array_range <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1f5081a54afbc2dfc1a7fb20329df7d5b">array_two</a>();
const_array_range <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1586cfbdef335f1d3d31faacec63f7b04">array_one</a>() const;
const_array_range <a href=
"circular_buffer.html#classboost_1_1circular__buffer_191a0e2c33c0e5b4d7b8c497847bc29ce">array_two</a>() const;
pointer <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1ea728bf57f91aa8946eddf76ce816a4e">linearize</a>();
size_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size</a>() const;
size_type <a href=
"circular_buffer.html#classboost_1_1circular__buffer_195158ed4d4b03794068e259f85291995">max_size</a>() const;
bool <a href=
"circular_buffer.html#classboost_1_1circular__buffer_105acab2b9a0b41044b5241cfc9d87663">empty</a>() const;
bool <a href="#classboost_1_1circular__buffer__space__optimized_15f5e6fb070d2484eaa037cdf4ffd69a8">full</a>() const;
size_type <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve</a>() const;
const capacity_type&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity</a>() const;
void <a href=
"#classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f">set_capacity</a>(const capacity_type&amp; capacity_ctrl);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1f244ff5576b79f8d60e273c02d71c9f2">resize</a>(size_type new_size, const_reference item = value_type());
void <a href=
"#classboost_1_1circular__buffer__space__optimized_10f096c108ebde69ae83a9de41b3bea56">rset_capacity</a>(const capacity_type&amp; capacity_ctrl);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1d45e2e72d9e3fb42e090ebc47ac8d7ee">rresize</a>(size_type new_size, const_reference item = value_type());
circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8">operator=</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; cb);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1">assign</a>(size_type n, const_reference item);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf">assign</a>(capacity_type capacity_ctrl, size_type n, const_reference item);
template &lt;class InputIterator&gt;
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb">assign</a>(InputIterator first, InputIterator last);
template &lt;class InputIterator&gt;
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b">assign</a>(capacity_type capacity_ctrl, InputIterator first, InputIterator last);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_14fd3b613f754d529ca250f2563b2f863">swap</a>(circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; cb);
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205">push_back</a>(const_reference item = value_type());
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c">push_front</a>(const_reference item = value_type());
void <a href="#classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6">pop_back</a>();
void <a href="#classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788">pop_front</a>();
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert</a>(iterator pos, const_reference item = value_type());
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert</a>(iterator pos, size_type n, const_reference item);
template &lt;class InputIterator&gt;
void <a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert</a>(iterator pos, InputIterator first, InputIterator last);
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert</a>(iterator pos, const_reference item = value_type());
void <a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert</a>(iterator pos, size_type n, const_reference item);
template &lt;class InputIterator&gt;
void <a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert</a>(iterator pos, InputIterator first, InputIterator last);
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase</a>(iterator pos);
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase</a>(iterator first, iterator last);
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1">rerase</a>(iterator pos);
iterator <a href=
"#classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98">rerase</a>(iterator first, iterator last);
void <a href="#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear</a>();
};
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_1d35871e838359b5215e1cbb353663207">operator==</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_195b08213f201c2067d8acb024756329d">operator&lt;</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_1f5717e2f6532581a6492ff1839b18f6d">operator!=</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_1f575d7a9741c2044424de50c966c12f3">operator&gt;</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_179abcbacd24b67f08185db54aec8600d">operator&lt;=</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
bool <a href=
"circular_buffer.html#namespaceboost_11c31150380272af67deebef578c80b05">operator&gt;=</a>(const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, const circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
template &lt;class T, class Alloc&gt;
void <a href=
"circular_buffer.html#namespaceboost_14aa8f6a2c9640f3f22e266f0fca85777">swap</a>(circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; lhs, circular_buffer_space_optimized&lt;T, Alloc&gt;&amp; rhs);
} // namespace boost
</pre>
</td>
</tr>
</table>
</div>
<h2>
<a name="rationale" id="rationale">Rationale</a>
</h2>
<p>
The auto-resizing mode of the space optimized circular buffer can be useful in situations when the container can
possibly store large number of elements but most of its lifetime the container stores just few of them. The usage
of the <code>circular_buffer_space_optimized</code> will result in decreased memory consumption and can improve
the CPU cache effectiveness.
</p>
<h2>
<a name="header" id="header">Header Files</a>
</h2>
<p>
The <code>circular_buffer_space_optimized</code> is defined in the file <code><a href=
"../../../boost/circular_buffer.hpp">boost/circular_buffer.hpp</a></code>. There is also a forward declaration
for the <code>circular_buffer_space_optimized</code> in the header file <code><a href=
"../../../boost/circular_buffer_fwd.hpp">boost/circular_buffer_fwd.hpp</a></code>.
</p>
<h2>
<a name="model" id="model">Modelled concepts</a>
</h2>
<p>
<a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">Random Access Container</a>, <a href=
"http://www.sgi.com/tech/stl/FrontInsertionSequence.html">Front Insertion Sequence</a> and <a href=
"http://www.sgi.com/tech/stl/BackInsertionSequence.html">Back Insertion Sequence</a>.
</p>
<h2>
<a name="types" id="types">Specific Public Types</a>
</h2>
<p>
Following public types are specific to the <code>circular_buffer_space_optimized</code>. Description of the
public types common with the <code>circular_buffer</code> can be found in the <code>circular_buffer</code>'s
<a href="circular_buffer.html#types">documentation</a>.
</p>
<div id="srcdoc_types">
<table id="table_public_types" border="1" cellpadding="3">
<tr>
<th>
Type
</th>
<th>
Description
</th>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0" name=
"classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0"><code>capacity_type</code></a>
</td>
<td>
Capacity controller of the space optimized circular buffer.
<pre>
class capacity_control {
size_type m_capacity;
size_type m_min_capacity;
public:
capacity_control(size_type capacity, size_type min_capacity = 0) : m_capacity(capacity), m_min_capacity(min_capacity) {};
size_type capacity() const { return m_capacity; }
size_type min_capacity() const { return m_min_capacity; }
operator size_type() const { return m_capacity; }
};
</pre>
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>capacity &gt;= min_capacity</code>
</dd>
</dl>The <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a></code>
represents the capacity of the <code>circular_buffer_space_optimized</code> and the
<code>min_capacity()</code> determines the minimal allocated size of its internal buffer. The converting
constructor of the <code>capacity_control</code> allows implicit conversion from
<code>size_type</code>-like types which ensures compatibility of creating an instance of the
<code>circular_buffer_space_optimized</code> with other STL containers. On the other hand the operator
<code>size_type()</code> provides implicit conversion to the <code>size_type</code> which allows to treat
the capacity of the <code>circular_buffer_space_optimized</code> the same way as in the <code><a href=
"circular_buffer.html">circular_buffer</a></code>.
</td>
</tr>
</table>
</div>
<h2>
<a name="constructors" id="constructors">Constructors and Destructor</a>
</h2>
<div id="srcdoc_constructors">
<table id="table_constructors" border="1" cellpadding="3">
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1a05f824b31cd93d7695f4039edc7597f" name=
"classboost_1_1circular__buffer__space__optimized_1a05f824b31cd93d7695f4039edc7597f"></a><code><b>explicit
circular_buffer_space_optimized(const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create an empty space optimized circular buffer with a maximum capacity.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
== <a href=
"circular_buffer.html#classboost_1_1circular__buffer_195158ed4d4b03794068e259f85291995">max_size()</a>
&amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.min_capacity()
== 0 &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
0</code><br>
<br>
There is no memory allocated in the internal buffer.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant.
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1741159a0511a4e0fed6eaab6d6959fa7" name=
"classboost_1_1circular__buffer__space__optimized_1741159a0511a4e0fed6eaab6d6959fa7"></a><code><b>explicit
circular_buffer_space_optimized(<a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create an empty space optimized circular buffer with the specified capacity.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
0</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>capacity_ctrl.min_capacity()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The capacity controller representing the maximum number of elements which can be stored in the
<code>circular_buffer_space_optimized</code> and the minimal allocated size of the internal buffer.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant.
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1f8c9fa872f9a84d454d7e245cc2eadbd" name=
"classboost_1_1circular__buffer__space__optimized_1f8c9fa872f9a84d454d7e245cc2eadbd"></a><code><b>circular_buffer_space_optimized(<a href="#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item, const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create a full space optimized circular buffer with the specified capacity filled with
<code>capacity_ctrl.capacity()</code> copies of <code>item</code>.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_15f5e6fb070d2484eaa037cdf4ffd69a8">full()</a>
&amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this)
[capacity_ctrl.capacity() - 1] == item</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>capacity_ctrl.capacity()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The capacity controller representing the maximum number of elements which can be stored in the
<code>circular_buffer_space_optimized</code> and the minimal allocated size of the internal buffer.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the created <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>capacity_ctrl.capacity()</code>).
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1d29ce80b10d4a3250fedeb9427210d96" name=
"classboost_1_1circular__buffer__space__optimized_1d29ce80b10d4a3250fedeb9427210d96"></a><code><b>circular_buffer_space_optimized(<a href="#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, <a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item, const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create a space optimized circular buffer with the specified capacity filled with <code>n</code> copies of
<code>item</code>.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>capacity_ctrl.capacity() &gt;= n</code>
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> == n
&amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this)[n - 1] ==
item</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>max[n,
capacity_ctrl.min_capacity()]</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The capacity controller representing the maximum number of elements which can be stored in the
<code>circular_buffer_space_optimized</code> and the minimal allocated size of the internal buffer.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>n</code>
</dt>
<dd>
The number of elements the created <code>circular_buffer_space_optimized</code> will be filled
with.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the created <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>n</code>).
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1d9f273c1a794f84484d220e977a3e24b" name=
"classboost_1_1circular__buffer__space__optimized_1d9f273c1a794f84484d220e977a3e24b"></a><code><b>circular_buffer_space_optimized(const
circular_buffer_space_optimized&lt;T,Alloc&gt;&amp; cb);</b></code><br>
<br>
The copy constructor.
<p>
Creates a copy of the specified <code>circular_buffer_space_optimized</code>.
</p>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code>*this == cb</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>cb.size()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>cb</code>
</dt>
<dd>
The <code>circular_buffer_space_optimized</code> to be copied.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of <code>cb</code>).
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_11dd04145492c82a959b1df1167b4e217" name=
"classboost_1_1circular__buffer__space__optimized_11dd04145492c82a959b1df1167b4e217"></a> <code><b>template
&lt;class InputIterator&gt;<br>
circular_buffer_space_optimized(InputIterator first, InputIterator last, const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create a full space optimized circular buffer filled with a copy of the range.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.<br>
<code>first</code> and <code>last</code> have to meet the requirements of <a href=
"http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
== std::distance(first, last) &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.min_capacity()
== 0 &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_15f5e6fb070d2484eaa037cdf4ffd69a8">full()</a>
&amp;&amp; (*this)[0]== *first &amp;&amp; (*this)[1] == *(first + 1) &amp;&amp; ... &amp;&amp;
(*this)[std::distance(first, last) - 1] == *(last - 1)</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>std::distance(first, last)</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>std::distance(first, last)</code>).
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_196c63e0ecd56f6f1ac87bc79d2fd5b9f" name=
"classboost_1_1circular__buffer__space__optimized_196c63e0ecd56f6f1ac87bc79d2fd5b9f"></a> <code><b>template
&lt;class InputIterator&gt;<br>
circular_buffer_space_optimized(<a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, InputIterator first, InputIterator last, const <a href=
"circular_buffer.html#classboost_1_1circular__buffer_14e07c6ddfe89debe384e59bed06e7cb7">allocator_type</a>&amp;
alloc = allocator_type());</b></code><br>
<br>
Create a space optimized circular buffer with the specified capacity (and the minimal guaranteed amount of
allocated memory) filled with a copy of the range.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.<br>
<code>first</code> and <code>last</code> have to meet the requirements of <a href=
"http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>
&lt;= std::distance(first, last) &amp;&amp; (*this)[0]== (last - capacity_ctrl.capacity()) &amp;&amp;
(*this)[1] == *(last - capacity_ctrl.capacity() + 1) &amp;&amp; ... &amp;&amp;
(*this)[capacity_ctrl.capacity() - 1] == *(last - 1)</code><br>
<br>
If the number of items to be copied from the range <code>[first, last)</code> is greater than the
specified <code>capacity_ctrl.capacity()</code> then only elements from the range <code>[last -
capacity_ctrl.capacity(), last)</code> will be copied.<br>
<br>
The amount of allocated memory in the internal buffer is <code>max[capacity_ctrl.min_capacity(),
min[capacity_ctrl.capacity(), std::distance(first, last)]]</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The capacity controller representing the maximum number of elements which can be stored in the
<code>circular_buffer_space_optimized</code> and the minimal allocated size of the internal buffer.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>alloc</code>
</dt>
<dd>
The allocator.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>std::distance(first, last)</code>; in <code>min[capacity_ctrl.capacity(),
std::distance(first, last)]</code> if the <code>InputIterator</code> is a <a href=
"http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_16839c3ea656ff0f800e38096748fe8ac" name=
"classboost_1_1circular__buffer__space__optimized_16839c3ea656ff0f800e38096748fe8ac"></a><code><b>~circular_buffer_space_optimized();</b></code><br>
<br>
The destructor.
<p>
Destroys the <code>circular_buffer_space_optimized</code>.
</p>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (including
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear()</a></code>
</dd>
</dl>
</td>
</tr>
</table>
</div>
<h2>
<a name="methods" id="methods">Specific Public Member Functions</a>
</h2>
<p>
Following public member functions of the <code>circular_buffer_space_optimized</code> have different behaviour
from the base <code>circular_buffer</code>. Description of the public member functions with the same behaviour
can be found in the <code>circular_buffer</code>'s <a href="circular_buffer.html#methods">documentation</a>.
</p>
<div id="srcdoc_methods">
<table id="table_methods" border="1" cellpadding="3">
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_15f5e6fb070d2484eaa037cdf4ffd69a8" name=
"classboost_1_1circular__buffer__space__optimized_15f5e6fb070d2484eaa037cdf4ffd69a8"></a><code><b>bool
full() const;</b></code><br>
<br>
Is the <code>circular_buffer_space_optimized</code> full?
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
<code>true</code> if the number of elements stored in the <code>circular_buffer_space_optimized</code>
equals the capacity of the <code>circular_buffer_space_optimized</code>; <code>false</code> otherwise.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
No-throw.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Does not invalidate any iterators.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_105acab2b9a0b41044b5241cfc9d87663">empty()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4" name=
"classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a>
reserve() const;</b></code><br>
<br>
Get the maximum number of elements which can be inserted into the
<code>circular_buffer_space_optimized</code> without overwriting any of already stored elements.
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
- <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a></code>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
No-throw.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Does not invalidate any iterators.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a></code>,
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a></code>,
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_195158ed4d4b03794068e259f85291995">max_size()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353" name=
"classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353"></a><code><b>const
<a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>&amp;
capacity() const;</b></code><br>
<br>
Get the capacity of the <code>circular_buffer_space_optimized</code>.
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
The capacity controller representing the maximum number of elements which can be stored in the
<code>circular_buffer_space_optimized</code> and the minimal allocated size of the internal buffer.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
No-throw.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Does not invalidate any iterators.
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a></code>,
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a></code>,
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_195158ed4d4b03794068e259f85291995">max_size()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f">set_capacity(const
capacity_type&amp;)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f" name=
"classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f"></a><code><b>void
set_capacity(const <a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>&amp;
capacity_ctrl);</b></code><br>
<br>
Change the capacity (and the minimal guaranteed amount of allocated memory) of the
<code>circular_buffer_space_optimized</code>.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>
&lt;= capacity_ctrl.capacity()</code><br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is greater
than the desired new capacity then number of <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> -
capacity_ctrl.capacity()]</code> <b>last</b> elements will be removed and the new size will be equal to
<code>capacity_ctrl.capacity()</code>.<br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is lower
than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as
necessary but it will never drop below <code>capacity_ctrl.min_capacity()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The new capacity controller.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Strong.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>min[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>,
capacity_ctrl.capacity()]</code>).
</dd>
</dl>
<dl>
<dt>
<b>Note:</b>
</dt>
<dd>
To explicitly clear the extra allocated memory use the <b>shrink-to-fit</b> technique:<br>
<br>
<code><a href=
"circular_buffer.html#namespaceboost">boost</a>::circular_buffer_space_optimized&lt;int&gt;
cb(1000);<br>
...<br>
<a href=
"circular_buffer.html#namespaceboost">boost</a>::circular_buffer_space_optimized&lt;int&gt;(cb).swap(cb);</code><br>
<br>
For more information about the shrink-to-fit technique in STL see <a href=
"http://www.gotw.ca/gotw/054.htm">http://www.gotw.ca/gotw/054.htm</a>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_10f096c108ebde69ae83a9de41b3bea56">rset_capacity(const
capacity_type&amp;)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1f244ff5576b79f8d60e273c02d71c9f2">resize(size_type,
const_reference)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1f244ff5576b79f8d60e273c02d71c9f2" name=
"classboost_1_1circular__buffer__space__optimized_1f244ff5576b79f8d60e273c02d71c9f2"></a><code><b>void
resize(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a>
new_size, <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Change the size of the <code>circular_buffer_space_optimized</code>.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
new_size &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
&gt;= new_size</code><br>
<br>
If the new size is greater than the current size, copies of <code>item</code> will be inserted at the
<b>back</b> of the of the <code>circular_buffer_space_optimized</code> in order to achieve the desired
size. In the case the resulting size exceeds the current capacity the capacity will be set to
<code>new_size</code>.<br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is greater
than the desired new size then number of <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> -
new_size]</code> <b>last</b> elements will be removed. (The capacity will remain unchanged.)<br>
<br>
The amount of allocated memory in the internal buffer may be accommodated as necessary.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>new_size</code>
</dt>
<dd>
The new size.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the <code>circular_buffer_space_optimized</code> will be filled with in order to gain
the requested size. (See the <i>Effect</i>.)
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the new size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1d45e2e72d9e3fb42e090ebc47ac8d7ee">rresize(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f">set_capacity(const
capacity_type&amp;)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_10f096c108ebde69ae83a9de41b3bea56" name=
"classboost_1_1circular__buffer__space__optimized_10f096c108ebde69ae83a9de41b3bea56"></a><code><b>void
rset_capacity(const <a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>&amp;
capacity_ctrl);</b></code><br>
<br>
Change the capacity (and the minimal guaranteed amount of allocated memory) of the
<code>circular_buffer_space_optimized</code>.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>
&lt;= capacity_ctrl</code><br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is greater
than the desired new capacity then number of <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> -
capacity_ctrl.capacity()]</code> <b>first</b> elements will be removed and the new size will be equal
to <code>capacity_ctrl.capacity()</code>.<br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is lower
than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as
necessary but it will never drop below <code>capacity_ctrl.min_capacity()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The new capacity controller.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Strong.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>min[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>,
capacity_ctrl.capacity()]</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_149f28bc5b33d2062b9f6a33b48264e3f">set_capacity(const
capacity_type&amp;)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1d45e2e72d9e3fb42e090ebc47ac8d7ee">rresize(size_type,
const_reference)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1d45e2e72d9e3fb42e090ebc47ac8d7ee" name=
"classboost_1_1circular__buffer__space__optimized_1d45e2e72d9e3fb42e090ebc47ac8d7ee"></a><code><b>void
rresize(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a>
new_size, <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Change the size of the <code>circular_buffer_space_optimized</code>.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
new_size &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
&gt;= new_size</code><br>
<br>
If the new size is greater than the current size, copies of <code>item</code> will be inserted at the
<b>front</b> of the of the <code>circular_buffer_space_optimized</code> in order to achieve the desired
size. In the case the resulting size exceeds the current capacity the capacity will be set to
<code>new_size</code>.<br>
<br>
If the current number of elements stored in the <code>circular_buffer_space_optimized</code> is greater
than the desired new size then number of <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> -
new_size]</code> <b>first</b> elements will be removed. (The capacity will remain unchanged.)<br>
<br>
The amount of allocated memory in the internal buffer may be accommodated as necessary.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>new_size</code>
</dt>
<dd>
The new size.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the <code>circular_buffer_space_optimized</code> will be filled with in order to gain
the requested size. (See the <i>Effect</i>.)
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the new size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1f244ff5576b79f8d60e273c02d71c9f2">resize(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_10f096c108ebde69ae83a9de41b3bea56">rset_capacity(const
capacity_type&amp;)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8" name=
"classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8"></a><code><b>circular_buffer_space_optimized&lt;T,Alloc&gt;&amp;
operator=(const circular_buffer_space_optimized&lt;T,Alloc&gt;&amp; cb);</b></code><br>
<br>
The assign operator.
<p>
Makes this <code>circular_buffer_space_optimized</code> to become a copy of the specified
<code>circular_buffer_space_optimized</code>.
</p>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code>*this == cb</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>cb.size()</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>cb</code>
</dt>
<dd>
The <code>circular_buffer_space_optimized</code> to be copied.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Strong.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to this <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of <code>cb</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1">assign(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf">assign(capacity_type,
size_type, const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb">assign(InputIterator,
InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b">assign(capacity_type,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1" name=
"classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1"></a><code><b>void
assign(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item);</b></code><br>
<br>
Assign <code>n</code> items into the space optimized circular buffer.
<p>
The content of the <code>circular_buffer_space_optimized</code> will be removed and replaced with
<code>n</code> copies of the <code>item</code>.
</p>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
== n &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.min_capacity()
== 0 &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> == n
&amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1]
== item</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>n</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>n</code>
</dt>
<dd>
The number of elements the <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>n</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8">operator=</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf">assign(capacity_type,
size_type, const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb">assign(InputIterator,
InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b">assign(capacity_type,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf" name=
"classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf"></a><code><b>void
assign(<a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, <a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item);</b></code><br>
<br>
Assign <code>n</code> items into the space optimized circular buffer specifying the capacity.
<p>
The capacity of the <code>circular_buffer_space_optimized</code> will be set to the specified value and
the content of the <code>circular_buffer_space_optimized</code> will be removed and replaced with
<code>n</code> copies of the <code>item</code>.
</p>
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>capacity_ctrl.capacity() &gt;= n</code>
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> == n
&amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1]
== item</code><br>
<br>
The amount of allocated memory will be <code>max[n, capacity_ctrl.min_capacity()]</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The new capacity controller.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>n</code>
</dt>
<dd>
The number of elements the <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element the <code>circular_buffer_space_optimized</code> will be filled with.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>n</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8">operator=</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1">assign(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb">assign(InputIterator,
InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b">assign(capacity_type,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb" name=
"classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb"></a> <code><b>template
&lt;class InputIterator&gt;<br>
void assign(InputIterator first, InputIterator last);</b></code><br>
<br>
Assign a copy of the range into the space optimized circular buffer.
<p>
The content of the <code>circular_buffer_space_optimized</code> will be removed and replaced with copies
of elements from the specified range.
</p>
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.<br>
<code>first</code> and <code>last</code> have to meet the requirements of <a href=
"http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
== std::distance(first, last) &amp;&amp; <a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.min_capacity()
== 0 &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
std::distance(first, last) &amp;&amp; (*this)[0]== *first &amp;&amp; (*this)[1] == *(first + 1)
&amp;&amp; ... &amp;&amp; (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br>
<br>
The amount of allocated memory in the internal buffer is <code>std::distance(first, last)</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be copied.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the <code>std::distance(first, last)</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8">operator=</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1">assign(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf">assign(capacity_type,
size_type, const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b">assign(capacity_type,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b" name=
"classboost_1_1circular__buffer__space__optimized_1e9347091d2d644854af0821d4b46869b"></a> <code><b>template
&lt;class InputIterator&gt;<br>
void assign(<a href=
"#classboost_1_1circular__buffer__space__optimized_1051350e031c50c8b4a7ca1e1902e92f0">capacity_type</a>
capacity_ctrl, InputIterator first, InputIterator last);</b></code><br>
<br>
Assign a copy of the range into the space optimized circular buffer specifying the capacity.
<p>
The capacity of the <code>circular_buffer_space_optimized</code> will be set to the specified value and
the content of the <code>circular_buffer_space_optimized</code> will be removed and replaced with copies
of elements from the specified range.
</p>
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.<br>
<code>first</code> and <code>last</code> have to meet the requirements of <a href=
"http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a> ==
capacity_ctrl &amp;&amp; <a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a>
&lt;= std::distance(first, last) &amp;&amp; (*this)[0]== *(last - capacity) &amp;&amp; (*this)[1] ==
*(last - capacity + 1) &amp;&amp; ... &amp;&amp; (*this)[capacity - 1] == *(last - 1)</code><br>
<br>
If the number of items to be copied from the range <code>[first, last)</code> is greater than the
specified <code>capacity</code> then only elements from the range <code>[last - capacity, last)</code>
will be copied.<br>
<br>
The amount of allocated memory in the internal buffer is <code>max[std::distance(first, last),
capacity_ctrl.min_capacity()]</code>.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>capacity_ctrl</code>
</dt>
<dd>
The new capacity controller.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be copied.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be copied.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>std::distance(first, last)</code>; in <code>min[capacity_ctrl.capacity(),
std::distance(first, last)]</code> if the <code>InputIterator</code> is a <a href=
"http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_177e35432c5e69b7a16ef7d937950e7a8">operator=</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_17ca4fda9526d0dad99706763c3b2d9f1">assign(size_type,
const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1108055ae3f6b1635e1428b0455902cbf">assign(capacity_type,
size_type, const_reference)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1417de2c2419c44d83a92c463762df5fb">assign(InputIterator,
InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_14fd3b613f754d529ca250f2563b2f863" name=
"classboost_1_1circular__buffer__space__optimized_14fd3b613f754d529ca250f2563b2f863"></a><code><b>void
swap(circular_buffer_space_optimized&lt;T,Alloc&gt;&amp; cb);</b></code><br>
<br>
Swap the contents of two space optimized circular buffers.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code>this</code> contains elements of <code>cb</code> and vice versa; the capacity and the amount of
allocated memory in the internal buffer of <code>this</code> equal to the capacity and the amount of
allocated memory of <code>cb</code> and vice versa.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>cb</code>
</dt>
<dd>
The <code>circular_buffer_space_optimized</code> whose content will be swapped.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
Nothing.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
No-throw.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators of both <code>circular_buffer_space_optimized</code> containers. (On the
other hand the iterators still point to the same elements but within another container. If you want to
rely on this feature you have to turn the <a href="circular_buffer.html#debug">Debug Support</a> off
otherwise an assertion will report an error if such invalidated iterator is used.)
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Constant (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"circular_buffer.html#namespaceboost_14aa8f6a2c9640f3f22e266f0fca85777">swap(circular_buffer_space_optimized&lt;T,
Alloc&gt;&amp;, circular_buffer_space_optimized&lt;T, Alloc&gt;&amp;)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205" name=
"classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205"></a><code><b>void
push_back(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Insert a new element at the end of the space optimized circular buffer.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
if <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
&gt; 0</code> then <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d985d974020f88bb4255d8edbae0a30a">back()</a> ==
item</code><br>
If the <code>circular_buffer_space_optimized</code> is full, the first element will be removed. If the
capacity is <code>0</code>, nothing will be inserted.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c">push_front(const_reference)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6">pop_back()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788">pop_front()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c" name=
"classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c"></a><code><b>void
push_front(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Insert a new element at the beginning of the space optimized circular buffer.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
if <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity()
&gt; 0</code> then <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_10d5fdeabeb352f47d1f7bb1ea8d9819f">front()</a> ==
item</code><br>
If the <code>circular_buffer_space_optimized</code> is full, the last element will be removed. If the
capacity is <code>0</code>, nothing will be inserted.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205">push_back(const_reference)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6">pop_back()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788">pop_front()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6" name=
"classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6"></a><code><b>void
pop_back();</b></code><br>
<br>
Remove the last element from the space optimized circular buffer.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>!empty()</code>
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The last element is removed from the <code>circular_buffer_space_optimized</code>.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788">pop_front()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205">push_back(const_reference)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c">push_front(const_reference)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788" name=
"classboost_1_1circular__buffer__space__optimized_1d7d496c40fc053258ac7d19cf5261788"></a><code><b>void
pop_front();</b></code><br>
<br>
Remove the first element from the space optimized circular buffer.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>!empty()</code>
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The first element is removed from the <code>circular_buffer_space_optimized</code>.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19c4290c18ab3dd2462dc01fb8368dff6">pop_back()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cf3ffed54f5fece9315fb96726e5e205">push_back(const_reference)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1f0484fd492b377ff80c0bcb76183162c">push_front(const_reference)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130" name=
"classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
insert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Insert an element at the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The <code>item</code> will be inserted at the position <code>pos</code>.<br>
If the <code>circular_buffer_space_optimized</code> is full, the first element will be overwritten. If
the <code>circular_buffer_space_optimized</code> is full and the <code>pos</code> points to
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a></code>,
then the <code>item</code> will not be inserted. If the capacity is <code>0</code>, nothing will be
inserted.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position where the <code>item</code> will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the inserted element or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a></code>
if the <code>item</code> is not inserted. (See the <i>Effect</i>.)
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert(iterator,
InputIterator, InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b" name=
"classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b"></a><code><b>void
insert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item);</b></code><br>
<br>
Insert <code>n</code> copies of the <code>item</code> at the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The number of <code>min[n, (pos - <a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a>) +
<a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]</code>
elements will be inserted at the position <code>pos</code>.<br>
The number of <code>min[pos - <a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a>,
max[0, n - <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]]</code>
elements will be overwritten at the beginning of the <code>circular_buffer_space_optimized</code>.<br>
(See <i>Example</i> for the explanation.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position where the <code>item</code>s will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>n</code>
</dt>
<dd>
The number of <code>item</code>s the to be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element whose copies will be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>min[<a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity(),
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
n]</code>).
</dd>
</dl>
<dl>
<dt>
<b>Example:</b>
</dt>
<dd>
Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
internal buffer may look like the one below.<br>
<br>
<code>|1|2|3|4| | |</code><br>
<code>p ---^</code><br>
<br>
After inserting 5 elements at the position <code>p</code>:<br>
<br>
<code>insert(p, (size_t)5, 0);</code><br>
<br>
actually only 4 elements get inserted and elements <code>1</code> and <code>2</code> are overwritten.
This is due to the fact the insert operation preserves the capacity. After insertion the internal
buffer looks like this:<br>
<br>
<code>|0|0|0|0|3|4|</code><br>
<br>
For comparison if the capacity would not be preserved the internal buffer would then result in
<code>|1|2|0|0|0|0|0|3|4|</code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert(iterator,
InputIterator, InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0" name=
"classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0"></a> <code><b>template
&lt;class InputIterator&gt;<br>
void insert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
InputIterator first, InputIterator last);</b></code><br>
<br>
Insert the range <code>[first, last)</code> at the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.<br>
Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
Elements from the range <code>[first + max[0, distance(first, last) - (pos - <a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a>) -
<a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>],
last)</code> will be inserted at the position <code>pos</code>.<br>
The number of <code>min[pos - <a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a>,
max[0, distance(first, last) - <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]]</code>
elements will be overwritten at the beginning of the <code>circular_buffer_space_optimized</code>.<br>
(See <i>Example</i> for the explanation.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position where the range will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
std::distance(first, last)]</code>; in <code>min[<a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity(),
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
std::distance(first, last)]</code> if the <code>InputIterator</code> is a <a href=
"http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
</dd>
</dl>
<dl>
<dt>
<b>Example:</b>
</dt>
<dd>
Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
internal buffer may look like the one below.<br>
<br>
<code>|1|2|3|4| | |</code><br>
<code>p ---^</code><br>
<br>
After inserting a range of elements at the position <code>p</code>:<br>
<br>
<code>int array[] = { 5, 6, 7, 8, 9 };</code><br>
<code>insert(p, array, array + 5);</code><br>
<br>
actually only elements <code>6</code>, <code>7</code>, <code>8</code> and <code>9</code> from the
specified range get inserted and elements <code>1</code> and <code>2</code> are overwritten. This is
due to the fact the insert operation preserves the capacity. After insertion the internal buffer looks
like this:<br>
<br>
<code>|6|7|8|9|3|4|</code><br>
<br>
For comparison if the capacity would not be preserved the internal buffer would then result in
<code>|1|2|5|6|7|8|9|3|4|</code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de" name=
"classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
rinsert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item = value_type());</b></code><br>
<br>
Insert an element before the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The <code>item</code> will be inserted before the position <code>pos</code>.<br>
If the <code>circular_buffer_space_optimized</code> is full, the last element will be overwritten. If
the <code>circular_buffer_space_optimized</code> is full and the <code>pos</code> points to
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>,
then the <code>item</code> will not be inserted. If the capacity is <code>0</code>, nothing will be
inserted.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position before which the <code>item</code> will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the inserted element or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>
if the <code>item</code> is not inserted. (See the <i>Effect</i>.)
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert(iterator,
InputIterator, InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d" name=
"classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d"></a><code><b>void
rinsert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_19ba12c0142a21a7d960877c22fa3ea00">size_type</a> n,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1a8397191092f5bacee991b623ca4b910">const_reference</a>
item);</b></code><br>
<br>
Insert <code>n</code> copies of the <code>item</code> before the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The number of <code>min[n, (<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a> -
pos) + <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]</code>
elements will be inserted before the position <code>pos</code>.<br>
The number of <code>min[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a> -
pos, max[0, n - <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]]</code>
elements will be overwritten at the end of the <code>circular_buffer_space_optimized</code>.<br>
(See <i>Example</i> for the explanation.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position where the <code>item</code>s will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>n</code>
</dt>
<dd>
The number of <code>item</code>s the to be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>item</code>
</dt>
<dd>
The element whose copies will be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>min[<a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity(),
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
n]</code>).
</dd>
</dl>
<dl>
<dt>
<b>Example:</b>
</dt>
<dd>
Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
internal buffer may look like the one below.<br>
<br>
<code>|1|2|3|4| | |</code><br>
<code>p ---^</code><br>
<br>
After inserting 5 elements before the position <code>p</code>:<br>
<br>
<code>rinsert(p, (size_t)5, 0);</code><br>
<br>
actually only 4 elements get inserted and elements <code>3</code> and <code>4</code> are overwritten.
This is due to the fact the rinsert operation preserves the capacity. After insertion the internal
buffer looks like this:<br>
<br>
<code>|1|2|0|0|0|0|</code><br>
<br>
For comparison if the capacity would not be preserved the internal buffer would then result in
<code>|1|2|0|0|0|0|0|3|4|</code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e">rinsert(iterator,
InputIterator, InputIterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e" name=
"classboost_1_1circular__buffer__space__optimized_1faeda7342f4717d7fb6b4589cb43b74e"></a> <code><b>template
&lt;class InputIterator&gt;<br>
void rinsert(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> pos,
InputIterator first, InputIterator last);</b></code><br>
<br>
Insert the range <code>[first, last)</code> before the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or
its end.<br>
Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
Elements from the range <code>[first, last - max[0, distance(first, last) - (<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a> -
pos) - <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>])</code>
will be inserted before the position <code>pos</code>.<br>
The number of <code>min[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a> -
pos, max[0, distance(first, last) - <a href=
"#classboost_1_1circular__buffer__space__optimized_100d0c06a38f789ae760709cc86420ae4">reserve()</a>]]</code>
elements will be overwritten at the end of the <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer">circular_buffer</a></code>.<br>
(See <i>Example</i> for the explanation.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively increased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator specifying the position where the range will be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be inserted.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be inserted.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::T(const T&amp;)</code> throws.
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in <code>[<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
std::distance(first, last)]</code>; in <code>min[<a href=
"#classboost_1_1circular__buffer__space__optimized_1ea8a89fbae5e03b364ac28e5dc49e353">capacity()</a>.capacity(),
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> +
std::distance(first, last)]</code> if the <code>InputIterator</code> is a <a href=
"http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
</dd>
</dl>
<dl>
<dt>
<b>Example:</b>
</dt>
<dd>
Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
internal buffer may look like the one below.<br>
<br>
<code>|1|2|3|4| | |</code><br>
<code>p ---^</code><br>
<br>
After inserting a range of elements before the position <code>p</code>:<br>
<br>
<code>int array[] = { 5, 6, 7, 8, 9 };</code><br>
<code>insert(p, array, array + 5);</code><br>
<br>
actually only elements <code>5</code>, <code>6</code>, <code>7</code> and <code>8</code> from the
specified range get inserted and elements <code>3</code> and <code>4</code> are overwritten. This is
due to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks
like this:<br>
<br>
<code>|1|2|5|6|7|8|</code><br>
<br>
For comparison if the capacity would not be preserved the internal buffer would then result in
<code>|1|2|5|6|7|8|9|3|4|</code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_1cb3586429e49eeb2df2d2a09e19775de">rinsert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_11eff7ec0eb603d489bd12f8c48928c9d">rinsert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_145877a0d46400f4894a13d25d138c130">insert(iterator,
value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_1dc2060ce1105d80429ff3f004ca0691b">insert(iterator,
size_type, value_type)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19eec983bc010f2e8415618455dd81da0">insert(iterator,
InputIterator, InputIterator)</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3" name=
"classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
erase(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
pos);</b></code><br>
<br>
Remove an element at the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> (but
not an <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The element at the position <code>pos</code> is removed.<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator pointing at the element to be removed.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the first element remaining beyond the removed element or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>
if no such element exists.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1">rerase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98">rerase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca" name=
"classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
erase(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> first,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
last);</b></code><br>
<br>
Erase the range <code>[first, last)</code>.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The elements from the range <code>[first, last)</code> are removed. (If <code>first == last</code>
nothing is removed.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be removed.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be removed.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the first element remaining beyond the removed elements or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>
if no such element exists.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1">rerase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98">rerase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1" name=
"classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
rerase(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
pos);</b></code><br>
<br>
Remove an element at the specified position.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
<code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> (but
not an <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The element at the position <code>pos</code> is removed.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>pos</code>
</dt>
<dd>
An iterator pointing at the element to be removed.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the first element remaining in front of the removed element or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a></code>
if no such element exists.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>Note:</b>
</dt>
<dd>
Basically there is no difference between <code><a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase(iterator)</a></code>
and this method. It is implemented only for consistency with the base <code><a href=
"circular_buffer.html">circular_buffer</a></code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98">rerase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98" name=
"classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98"></a><code><b><a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
rerase(<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a> first,
<a href=
"circular_buffer.html#classboost_1_1circular__buffer_11b8a33f2dc8519b8a7d344ed4408c532">iterator</a>
last);</b></code><br>
<br>
Erase the range <code>[first, last)</code>.
<dl>
<dt>
<b>Precondition:</b>
</dt>
<dd>
Valid range <code>[first, last)</code>.
</dd>
</dl>
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
The elements from the range <code>[first, last)</code> are removed. (If <code>first == last</code>
nothing is removed.)<br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Parameter(s):</b>
</dt>
<dd>
<dl compact>
<dt>
<code>first</code>
</dt>
<dd>
The beginning of the range to be removed.
</dd>
</dl>
</dd>
<dd>
<dl compact>
<dt>
<code>last</code>
</dt>
<dd>
The end of the range to be removed.
</dd>
</dl>
</dd>
</dl>
<dl>
<dt>
<b>Returns:</b>
</dt>
<dd>
Iterator to the first element remaining in front of the removed elements or <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_158d1ede2e85f5d46eda8db3f0c4efef0">begin()</a></code>
if no such element exists.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
<dd>
Whatever <code>T::operator = (const T&amp;)</code> throws.
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>Note:</b>
</dt>
<dd>
Basically there is no difference between <code><a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase(iterator,
iterator)</a></code> and this method. It is implemented only for consistency with the base
<code><a href="circular_buffer.html">circular_buffer</a></code>.
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1">rerase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab">clear()</a></code>
</dd>
</dl>
</td>
</tr>
<tr>
<td>
<a id="classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab" name=
"classboost_1_1circular__buffer__space__optimized_12aa1dd29bd9509b5482ca2666c61deab"></a><code><b>void
clear();</b></code><br>
<br>
Remove all stored elements from the space optimized circular buffer.
<dl>
<dt>
<b>Effect:</b>
</dt>
<dd>
<code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1d666f694897465b0d4d7cdd8ddcbc213">size()</a> ==
0</code><br>
<br>
The amount of allocated memory in the internal buffer may be predictively decreased.
</dd>
</dl>
<dl>
<dt>
<b>Throws:</b>
</dt>
<dd>
An allocation error if memory is exhausted (<code>std::bad_alloc</code> if the standard allocator is
used).
</dd>
</dl>
<dl>
<dt>
<b>Exception Safety:</b>
</dt>
<dd>
Basic.
</dd>
</dl>
<dl>
<dt>
<b>Iterator Invalidation:</b>
</dt>
<dd>
Invalidates all iterators pointing to the <code>circular_buffer_space_optimized</code> (except
iterators equal to <code><a href=
"circular_buffer.html#classboost_1_1circular__buffer_1babfa093dad7801223b80626b598dee1">end()</a></code>).
</dd>
</dl>
<dl>
<dt>
<b>Complexity:</b>
</dt>
<dd>
Linear (in the size of the <code>circular_buffer_space_optimized</code>).
</dd>
</dl>
<dl>
<dt>
<b>See Also:</b>
</dt>
<dd>
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_16839c3ea656ff0f800e38096748fe8ac">~circular_buffer_space_optimized()</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_136feadef225bd8a10962a92c4ffcdfd3">erase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_19e9a4e0dfca27329da78e014d97201ca">erase(iterator,
iterator)</a></code>, <code><a href=
"#classboost_1_1circular__buffer__space__optimized_16e96800422211d02621526c894b71fa1">rerase(iterator)</a></code>,
<code><a href=
"#classboost_1_1circular__buffer__space__optimized_154fd4c2a67c7d6de6cbf6c8255729e98">rerase(iterator,
iterator)</a></code>
</dd>
</dl>
</td>
</tr>
</table>
</div>
<h2>
<a name="see" id="see">See also</a>
</h2>
<p>
<code><a href="circular_buffer.html">boost::circular_buffer</a>, <a href=
"http://www.sgi.com/tech/stl/Vector.html">std::vector</a></code>
</p>
<h2>
<a name="ack" id="ack">Acknowledgements</a>
</h2>
<p>
The idea of the space optimized circular buffer has been introduced by Pavel Vozenilek.
</p>
<hr size="1">
<table id="footer" border="0" width="100%">
<tr>
<td align="left" valign="top">
<p>
<small>Copyright <20> 2003-2007 Jan Gaspar</small>
</p>
<p>
<small>Use, modification, and distribution is subject to the Boost Software License, Version 1.0.<br>
(See accompanying file <code>LICENSE_1_0.txt</code> or copy at <a href=
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</small>
</p>
</td>
<td align="right" valign="top">
<a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
"http://www.w3.org/Icons/valid-html401" alt="This is a Valid HTML 4.01 Transitional Document." height="31"
width="88"></a>
</td>
</tr>
</table>
</body>
</html>