doc/html/boost/circular_buffe_idp31480224.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Class template circular_buffer_space_optimized</title>
   5 <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
   7 <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
   8 <link rel="up" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp" title="Header &lt;boost/circular_buffer/space_optimized.hpp&gt;">
   9 <link rel="prev" href="swap_idp31458912.html" title="Function template swap">
  10 <link rel="next" href="../circular_buffer/s14.html" title="Index">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
  15 <td align="center"><a href="../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="swap_idp31458912.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../circular_buffer/s14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="refentry">
  26 <a name="boost.circular_buffe_idp31480224"></a><div class="titlepage"></div>
  27 <div class="refnamediv">
  28 <h2><span class="refentrytitle">Class template circular_buffer_space_optimized</span></h2>
  29 <p>boost::circular_buffer_space_optimized &#8212; Space optimized circular buffer container adaptor. <code class="computeroutput">T</code> must be a copyable class or must have an noexcept move constructor and move assignment operator. </p>
  30 </div>
  31 <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2>
  32 <div xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp" title="Header &lt;boost/circular_buffer/space_optimized.hpp&gt;">boost/circular_buffer/space_optimized.hpp</a>&gt;
  33
  34 </span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span>
  35 <span class="keyword">class</span> <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a> <span class="special">:</span>
  36   <span class="keyword">private</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">circular_buffer</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span>
  37 <span class="special">{</span>
  38 <span class="keyword">public</span><span class="special">:</span>
  39   <span class="comment">// <a class="link" href="circular_buffe_idp31480224.html#boost.circular_buffe_idp31480224types">types</a></span>
  40   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span>             <a name="boost.circular_buffe_idp31480224.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>
  41   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">pointer</span>                <a name="boost.circular_buffe_idp31480224.pointer"></a><span class="identifier">pointer</span><span class="special">;</span>
  42   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_pointer</span>          <a name="boost.circular_buffe_idp31480224.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>
  43   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">reference</span>              <a name="boost.circular_buffe_idp31480224.reference"></a><span class="identifier">reference</span><span class="special">;</span>
  44   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_reference</span>        <a name="boost.circular_buffe_idp31480224.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>
  45   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span>              <a name="boost.circular_buffe_idp31480224.size_type"></a><span class="identifier">size_type</span><span class="special">;</span>
  46   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">difference_type</span>        <a name="boost.circular_buffe_idp31480224.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span>
  47   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">allocator_type</span>         <a name="boost.circular_buffe_idp31480224.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span>
  48   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_iterator</span>         <a name="boost.circular_buffe_idp31480224.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span>
  49   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">iterator</span>               <a name="boost.circular_buffe_idp31480224.iterator"></a><span class="identifier">iterator</span><span class="special">;</span>
  50   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_reverse_iterator</span> <a name="boost.circular_buffe_idp31480224.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
  51   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">reverse_iterator</span>       <a name="boost.circular_buffe_idp31480224.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>
  52   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">array_range</span>            <a name="boost.circular_buffe_idp31480224.array_range"></a><span class="identifier">array_range</span><span class="special">;</span>
  53   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">const_array_range</span>      <a name="boost.circular_buffe_idp31480224.const_array_range"></a><span class="identifier">const_array_range</span><span class="special">;</span>
  54   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">param_value_type</span>       <a name="boost.circular_buffe_idp31480224.param_value_type"></a><span class="identifier">param_value_type</span><span class="special">;</span>
  55   <span class="keyword">typedef</span> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">rvalue_type</span>            <a name="boost.circular_buffe_idp31480224.rvalue_type"></a><span class="identifier">rvalue_type</span><span class="special">;</span>
  56   <span class="keyword">typedef</span> cb_details::capacity_control<span class="special">&lt;</span> <span class="identifier">size_type</span> <span class="special">&gt;</span>           <a class="link" href="circular_buffe_idp31480224.html#boost.circular_buffe_idp31480224.capacity_type"><span class="identifier">capacity_type</span></a><span class="special">;</span>
  57
  58   <span class="comment">// <a class="link" href="circular_buffe_idp31480224.html#boost.circular_buffe_idp31480224construct-copy-destruct">construct/copy/destruct</a></span>
  59   <span class="keyword">explicit</span> <a class="link" href="circular_buffe_idp31480224.html#idp32214432-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  60   <span class="keyword">explicit</span> <a class="link" href="circular_buffe_idp31480224.html#idp32220448-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span>
  61                                            <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  62   <a class="link" href="circular_buffe_idp31480224.html#idp32228992-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">,</span>
  63                                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  64   <a class="link" href="circular_buffe_idp31480224.html#idp32241184-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">,</span>
  65                                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  66   <a class="link" href="circular_buffe_idp31480224.html#idp32256048-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  67   <a class="link" href="circular_buffe_idp31480224.html#idp32264960-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  68   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  69     <a class="link" href="circular_buffe_idp31480224.html#idp32272672-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  70                                     <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  71   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  72     <a class="link" href="circular_buffe_idp31480224.html#idp32286736-bb"><span class="identifier">circular_buffer_space_optimized</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  73                                     <span class="identifier">InputIterator</span><span class="special">,</span>
  74                                     <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  75   <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
  76   <a class="link" href="circular_buffe_idp31480224.html#idp32305904-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  77   <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
  78   <a class="link" href="circular_buffe_idp31480224.html#idp32322240-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  79
  80   <span class="comment">// <a class="link" href="circular_buffe_idp31480224.html#idp31516928-bb">public member functions</a></span>
  81   <span class="keyword">bool</span> <a class="link" href="circular_buffe_idp31480224.html#idp31517488-bb"><span class="identifier">full</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  82   <span class="identifier">size_type</span> <a class="link" href="circular_buffe_idp31480224.html#idp31528784-bb"><span class="identifier">reserve</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  83   <span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> <a class="link" href="circular_buffe_idp31480224.html#idp31538816-bb"><span class="identifier">capacity</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  84   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31549952-bb"><span class="identifier">set_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  85   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31572144-bb"><span class="identifier">resize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  86   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31594080-bb"><span class="identifier">rset_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  87   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31612032-bb"><span class="identifier">rresize</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  88   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31633968-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
  89   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31652448-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
  90   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31673680-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  91   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  92     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31693824-bb"><span class="identifier">assign</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  93   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31719696-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  94   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31733424-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
  95   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31748496-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span>
  96   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31763104-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  97   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31777952-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
  98   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31793024-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span>
  99   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31808544-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 100   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31823392-bb"><span class="identifier">pop_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 101   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31836048-bb"><span class="identifier">pop_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 102   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp31848704-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
 103   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp31872608-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span>
 104   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp31896496-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 105   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31919712-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
 106   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 107     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp31951152-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
 108   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp31988656-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
 109   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32012544-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">rvalue_type</span><span class="special">)</span><span class="special">;</span>
 110   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32036416-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 111   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32059616-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">)</span><span class="special">;</span>
 112   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 113     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32091024-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
 114   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32128528-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 115   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32145520-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 116   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32163296-bb"><span class="identifier">rerase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 117   <span class="identifier">iterator</span> <a class="link" href="circular_buffe_idp31480224.html#idp32182256-bb"><span class="identifier">rerase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 118   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32202176-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 119
 120   <span class="comment">// <a class="link" href="circular_buffe_idp31480224.html#idp32330288-bb">private member functions</a></span>
 121   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32330864-bb"><span class="identifier">adjust_min_capacity</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 122   <span class="identifier">size_type</span> <a class="link" href="circular_buffe_idp31480224.html#idp32332016-bb"><span class="identifier">ensure_reserve</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 123   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32334832-bb"><span class="identifier">check_low_capacity</span></a><span class="special">(</span><span class="identifier">size_type</span> <span class="special">=</span> <span class="number">1</span><span class="special">)</span><span class="special">;</span>
 124   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32336960-bb"><span class="identifier">check_high_capacity</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 125   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32338112-bb"><span class="identifier">reduce_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 126   <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32339968-bb"><span class="identifier">reduce_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 127   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
 128     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32341824-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span>
 129                 <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 130   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
 131     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32346576-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 132   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
 133     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32351328-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span>
 134                  <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 135   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
 136     <span class="keyword">void</span> <a class="link" href="circular_buffe_idp31480224.html#idp32356080-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 137
 138   <span class="comment">// <a class="link" href="circular_buffe_idp31480224.html#idp32360992-bb">private static functions</a></span>
 139   <span class="keyword">static</span> <span class="identifier">size_type</span> <a class="link" href="circular_buffe_idp31480224.html#idp32361568-bb"><span class="identifier">init_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 140   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
 141     <span class="keyword">static</span> <span class="identifier">size_type</span>
 142     <a class="link" href="circular_buffe_idp31480224.html#idp32364368-bb"><span class="identifier">init_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span> <span class="identifier">IntegralType</span><span class="special">,</span>
 143                   <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 144   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
 145     <span class="keyword">static</span> <span class="identifier">size_type</span>
 146     <a class="link" href="circular_buffe_idp31480224.html#idp32369424-bb"><span class="identifier">init_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span>
 147                   <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 148   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 149     <span class="keyword">static</span> <span class="identifier">size_type</span>
 150     <a class="link" href="circular_buffe_idp31480224.html#idp32374480-bb"><span class="identifier">init_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
 151                   <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">input_iterator_tag</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 152   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIterator<span class="special">&gt;</span>
 153     <span class="keyword">static</span> <span class="identifier">size_type</span>
 154     <a class="link" href="circular_buffe_idp31480224.html#idp32379552-bb"><span class="identifier">init_capacity</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span>
 155                   <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 156 <span class="special">}</span><span class="special">;</span></pre></div>
 157 <div class="refsect1">
 158 <a name="idp146544208"></a><h2>Description</h2>
 159 <div class="refsect2">
 160 <a name="idp146544624"></a><h3>
 161 <a name="boost.circular_buffe_idp31480224types"></a><code class="computeroutput">circular_buffer_space_optimized</code>
 162         public
 163        types</h3>
 164 <div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
 165 <p>
 166 <span class="keyword">typedef</span> cb_details::capacity_control<span class="special">&lt;</span> <span class="identifier">size_type</span> <span class="special">&gt;</span> <a name="boost.circular_buffe_idp31480224.capacity_type"></a><span class="identifier">capacity_type</span><span class="special">;</span></p>
 167 <p>Capacity controller of the space optimized circular buffer.</p>
 168 <p><span class="bold"><strong>See Also:</strong></span></p>
 169 <p>capacity_control in details.hpp. </p>
 170 <p>
 171 <code class="computeroutput"> class capacity_control<br>
 172  {<br>
 173  size_type m_capacity; // Available capacity.<br>
 174  size_type m_min_capacity; // Minimum capacity.<br>
 175  public:<br>
 176  capacity_control(size_type capacity, size_type min_capacity = 0)<br>
 177  : m_capacity(capacity), m_min_capacity(min_capacity)<br>
 178  {};<br>
 179  size_type capacity() const { return m_capacity; }<br>
 180  size_type min_capacity() const { return m_min_capacity; }<br>
 181  operator size_type() const { return m_capacity; }<br>
 182  };<br>
 183  </code> </p>
 184 <p>Always <code class="computeroutput">capacity &gt;= min_capacity</code>. </p>
 185 <p>The <code class="computeroutput">capacity()</code> represents the capacity of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> and the <code class="computeroutput">min_capacity()</code> determines the minimal allocated size of its internal buffer. </p>
 186 <p>The converting constructor of the <code class="computeroutput">capacity_control</code> allows implicit conversion from <code class="computeroutput">size_type</code>-like types which ensures compatibility of creating an instance of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> with other STL containers.</p>
 187 <p>On the other hand the operator <code class="computeroutput">size_type()</code> provides implicit conversion to the <code class="computeroutput">size_type</code> which allows to treat the capacity of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> the same way as in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p>
 188 </li></ol></div>
 189 </div>
 190 <div class="refsect2">
 191 <a name="idp146569248"></a><h3>
 192 <a name="boost.circular_buffe_idp31480224construct-copy-destruct"></a><code class="computeroutput">circular_buffer_space_optimized</code>
 193         public
 194        construct/copy/destruct</h3>
 195 <div class="orderedlist"><ol class="orderedlist" type="1">
 196 <li class="listitem">
 197 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idp32214432-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Create an empty space optimized circular buffer with zero capacity. <p>
 198
 199
 200 </p>
 201 <p><b>Complexity.&#160;</b>Constant. </p>
 202 <p>
 203 </p>
 204 <div class="warning"><table border="0" summary="Warning">
 205 <tr>
 206 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
 207 <th align="left">Warning</th>
 208 </tr>
 209 <tr><td align="left" valign="top"><p>Since Boost version 1.36 the behaviour of this constructor has changed. Now it creates a space optimized circular buffer with zero capacity. </p></td></tr>
 210 </table></div>
 211 <p>
 212 </p>
 213 <div class="variablelist"><table border="0" class="variablelist compact">
 214 <colgroup>
 215 <col align="left" valign="top">
 216 <col>
 217 </colgroup>
 218 <tbody>
 219 <tr>
 220 <td><p><span class="term">Parameters:</span></p></td>
 221 <td><div class="variablelist"><table border="0" class="variablelist compact">
 222 <colgroup>
 223 <col align="left" valign="top">
 224 <col>
 225 </colgroup>
 226 <tbody><tr>
 227 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 228 <td><p>The allocator. </p></td>
 229 </tr></tbody>
 230 </table></div></td>
 231 </tr>
 232 <tr>
 233 <td><p><span class="term">Postconditions:</span></p></td>
 234 <td><p><code class="computeroutput">capacity().capacity() == 0 &amp;&amp; capacity().min_capacity() == 0 &amp;&amp; size() == 0</code> </p></td>
 235 </tr>
 236 <tr>
 237 <td><p><span class="term">Throws:</span></p></td>
 238 <td>Nothing. </td>
 239 </tr>
 240 </tbody>
 241 </table></div>
 242 </li>
 243 <li class="listitem">
 244 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idp32220448-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span>
 245                                          <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create an empty space optimized circular buffer with the specified capacity. <p>
 246
 247
 248 </p>
 249 <p><b>Complexity.&#160;</b>Constant. </p>
 250 <p>
 251 </p>
 252 <div class="variablelist"><table border="0" class="variablelist compact">
 253 <colgroup>
 254 <col align="left" valign="top">
 255 <col>
 256 </colgroup>
 257 <tbody>
 258 <tr>
 259 <td><p><span class="term">Parameters:</span></p></td>
 260 <td><div class="variablelist"><table border="0" class="variablelist compact">
 261 <colgroup>
 262 <col align="left" valign="top">
 263 <col>
 264 </colgroup>
 265 <tbody>
 266 <tr>
 267 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 268 <td><p>The allocator. </p></td>
 269 </tr>
 270 <tr>
 271 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 272 <td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td>
 273 </tr>
 274 </tbody>
 275 </table></div></td>
 276 </tr>
 277 <tr>
 278 <td><p><span class="term">Postconditions:</span></p></td>
 279 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() == 0</code><br>
 280 <br>
 281  The amount of allocated memory in the internal buffer is <code class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td>
 282 </tr>
 283 <tr>
 284 <td><p><span class="term">Throws:</span></p></td>
 285 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
 286 </tr>
 287 </tbody>
 288 </table></div>
 289 </li>
 290 <li class="listitem">
 291 <pre class="literallayout"><a name="idp32228992-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span>
 292                                 <span class="identifier">param_value_type</span> item<span class="special">,</span>
 293                                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a full space optimized circular buffer with the specified capacity filled with <code class="computeroutput">capacity_ctrl.capacity()</code> copies of <code class="computeroutput">item</code>. <p>
 294
 295
 296 </p>
 297 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">capacity_ctrl.capacity()</code>). </p>
 298 <p>
 299 </p>
 300 <div class="variablelist"><table border="0" class="variablelist compact">
 301 <colgroup>
 302 <col align="left" valign="top">
 303 <col>
 304 </colgroup>
 305 <tbody>
 306 <tr>
 307 <td><p><span class="term">Parameters:</span></p></td>
 308 <td><div class="variablelist"><table border="0" class="variablelist compact">
 309 <colgroup>
 310 <col align="left" valign="top">
 311 <col>
 312 </colgroup>
 313 <tbody>
 314 <tr>
 315 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 316 <td><p>The allocator. </p></td>
 317 </tr>
 318 <tr>
 319 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 320 <td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td>
 321 </tr>
 322 <tr>
 323 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
 324 <td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
 325 </tr>
 326 </tbody>
 327 </table></div></td>
 328 </tr>
 329 <tr>
 330 <td><p><span class="term">Postconditions:</span></p></td>
 331 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; full() &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [capacity_ctrl.capacity() - 1] == item </code><br>
 332 <br>
 333  The amount of allocated memory in the internal buffer is <code class="computeroutput">capacity_ctrl.capacity()</code>. </p></td>
 334 </tr>
 335 <tr>
 336 <td><p><span class="term">Throws:</span></p></td>
 337 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 338 </tr>
 339 </tbody>
 340 </table></div>
 341 </li>
 342 <li class="listitem">
 343 <pre class="literallayout"><a name="idp32241184-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span>
 344                                 <span class="identifier">param_value_type</span> item<span class="special">,</span>
 345                                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a space optimized circular buffer with the specified capacity filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p>
 346
 347
 348
 349 </p>
 350 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
 351 <p>
 352 </p>
 353 <div class="variablelist"><table border="0" class="variablelist compact">
 354 <colgroup>
 355 <col align="left" valign="top">
 356 <col>
 357 </colgroup>
 358 <tbody>
 359 <tr>
 360 <td><p><span class="term">Parameters:</span></p></td>
 361 <td><div class="variablelist"><table border="0" class="variablelist compact">
 362 <colgroup>
 363 <col align="left" valign="top">
 364 <col>
 365 </colgroup>
 366 <tbody>
 367 <tr>
 368 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 369 <td><p>The allocator. </p></td>
 370 </tr>
 371 <tr>
 372 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 373 <td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td>
 374 </tr>
 375 <tr>
 376 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
 377 <td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
 378 </tr>
 379 <tr>
 380 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
 381 <td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
 382 </tr>
 383 </tbody>
 384 </table></div></td>
 385 </tr>
 386 <tr>
 387 <td><p><span class="term">Requires:</span></p></td>
 388 <td><p><code class="computeroutput">capacity_ctrl.capacity() &gt;= n</code> </p></td>
 389 </tr>
 390 <tr>
 391 <td><p><span class="term">Postconditions:</span></p></td>
 392 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this)[n - 1] == item</code><br>
 393 <br>
 394  The amount of allocated memory in the internal buffer is <code class="computeroutput">max[n, capacity_ctrl.min_capacity()]</code>. </p></td>
 395 </tr>
 396 <tr>
 397 <td><p><span class="term">Throws:</span></p></td>
 398 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 399 </tr>
 400 </tbody>
 401 </table></div>
 402 </li>
 403 <li class="listitem">
 404 <pre class="literallayout"><a name="idp32256048-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span> cb<span class="special">)</span><span class="special">;</span></pre>The copy constructor. <p>Creates a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>.
 405
 406
 407 </p>
 408 <p><b>Complexity.&#160;</b>Linear (in the size of <code class="computeroutput">cb</code>). </p>
 409 <p>
 410 </p>
 411 <div class="variablelist"><table border="0" class="variablelist compact">
 412 <colgroup>
 413 <col align="left" valign="top">
 414 <col>
 415 </colgroup>
 416 <tbody>
 417 <tr>
 418 <td><p><span class="term">Parameters:</span></p></td>
 419 <td><div class="variablelist"><table border="0" class="variablelist compact">
 420 <colgroup>
 421 <col align="left" valign="top">
 422 <col>
 423 </colgroup>
 424 <tbody><tr>
 425 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 426 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to be copied. </p></td>
 427 </tr></tbody>
 428 </table></div></td>
 429 </tr>
 430 <tr>
 431 <td><p><span class="term">Postconditions:</span></p></td>
 432 <td><p><code class="computeroutput">*this == cb</code><br>
 433 <br>
 434  The amount of allocated memory in the internal buffer is <code class="computeroutput">cb.size()</code>. </p></td>
 435 </tr>
 436 <tr>
 437 <td><p><span class="term">Throws:</span></p></td>
 438 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 439 </tr>
 440 </tbody>
 441 </table></div>
 442 </li>
 443 <li class="listitem">
 444 <pre class="literallayout"><a name="idp32264960-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>The move constructor. <p>Move constructs a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> from <code class="computeroutput">cb</code>, leaving <code class="computeroutput">cb</code> empty.
 445
 446
 447
 448 </p>
 449 <p><b>Constant.&#160;</b></p>
 450 <p>
 451 </p>
 452 <div class="variablelist"><table border="0" class="variablelist compact">
 453 <colgroup>
 454 <col align="left" valign="top">
 455 <col>
 456 </colgroup>
 457 <tbody>
 458 <tr>
 459 <td><p><span class="term">Parameters:</span></p></td>
 460 <td><div class="variablelist"><table border="0" class="variablelist compact">
 461 <colgroup>
 462 <col align="left" valign="top">
 463 <col>
 464 </colgroup>
 465 <tbody><tr>
 466 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 467 <td><p><code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to 'steal' value from. </p></td>
 468 </tr></tbody>
 469 </table></div></td>
 470 </tr>
 471 <tr>
 472 <td><p><span class="term">Requires:</span></p></td>
 473 <td><p>C++ compiler with rvalue references support. </p></td>
 474 </tr>
 475 <tr>
 476 <td><p><span class="term">Postconditions:</span></p></td>
 477 <td><p><code class="computeroutput">cb.empty()</code> </p></td>
 478 </tr>
 479 <tr>
 480 <td><p><span class="term">Throws:</span></p></td>
 481 <td>Nothing. </td>
 482 </tr>
 483 </tbody>
 484 </table></div>
 485 </li>
 486 <li class="listitem">
 487 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 488   <a name="idp32272672-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
 489                                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Create a full space optimized circular buffer filled with a copy of the range. <p>
 490
 491
 492
 493 </p>
 494 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p>
 495 <p>
 496 </p>
 497 <div class="variablelist"><table border="0" class="variablelist compact">
 498 <colgroup>
 499 <col align="left" valign="top">
 500 <col>
 501 </colgroup>
 502 <tbody>
 503 <tr>
 504 <td><p><span class="term">Parameters:</span></p></td>
 505 <td><div class="variablelist"><table border="0" class="variablelist compact">
 506 <colgroup>
 507 <col align="left" valign="top">
 508 <col>
 509 </colgroup>
 510 <tbody>
 511 <tr>
 512 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 513 <td><p>The allocator. </p></td>
 514 </tr>
 515 <tr>
 516 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
 517 <td><p>The beginning of the range to be copied. </p></td>
 518 </tr>
 519 <tr>
 520 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
 521 <td><p>The end of the range to be copied. </p></td>
 522 </tr>
 523 </tbody>
 524 </table></div></td>
 525 </tr>
 526 <tr>
 527 <td><p><span class="term">Requires:</span></p></td>
 528 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
 529  <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
 530 </tr>
 531 <tr>
 532 <td><p><span class="term">Postconditions:</span></p></td>
 533 <td><p><code class="computeroutput">capacity().capacity() == std::distance(first, last) &amp;&amp; capacity().min_capacity() == 0 &amp;&amp; full() &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>
 534 <br>
 535  The amount of allocated memory in the internal buffer is <code class="computeroutput">std::distance(first, last)</code>. </p></td>
 536 </tr>
 537 <tr>
 538 <td><p><span class="term">Throws:</span></p></td>
 539 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td>
 540 </tr>
 541 </tbody>
 542 </table></div>
 543 </li>
 544 <li class="listitem">
 545 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 546   <a name="idp32286736-bb"></a><span class="identifier">circular_buffer_space_optimized</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span>
 547                                   <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
 548                                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> alloc <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>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. <p>
 549
 550
 551
 552 </p>
 553 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[capacity_ctrl.capacity(), std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p>
 554 <p>
 555 </p>
 556 <div class="variablelist"><table border="0" class="variablelist compact">
 557 <colgroup>
 558 <col align="left" valign="top">
 559 <col>
 560 </colgroup>
 561 <tbody>
 562 <tr>
 563 <td><p><span class="term">Parameters:</span></p></td>
 564 <td><div class="variablelist"><table border="0" class="variablelist compact">
 565 <colgroup>
 566 <col align="left" valign="top">
 567 <col>
 568 </colgroup>
 569 <tbody>
 570 <tr>
 571 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 572 <td><p>The allocator. </p></td>
 573 </tr>
 574 <tr>
 575 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 576 <td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> and the minimal allocated size of the internal buffer. </p></td>
 577 </tr>
 578 <tr>
 579 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
 580 <td><p>The beginning of the range to be copied. </p></td>
 581 </tr>
 582 <tr>
 583 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
 584 <td><p>The end of the range to be copied. </p></td>
 585 </tr>
 586 </tbody>
 587 </table></div></td>
 588 </tr>
 589 <tr>
 590 <td><p><span class="term">Requires:</span></p></td>
 591 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
 592  <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
 593 </tr>
 594 <tr>
 595 <td><p><span class="term">Postconditions:</span></p></td>
 596 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() &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>
 597 <br>
 598  If the number of items to be copied from the range <code class="computeroutput">[first, last)</code> is greater than the specified <code class="computeroutput">capacity_ctrl.capacity()</code> then only elements from the range <code class="computeroutput">[last - capacity_ctrl.capacity(), last)</code> will be copied.<br>
 599 <br>
 600  The amount of allocated memory in the internal buffer is <code class="computeroutput">max[capacity_ctrl.min_capacity(), min[capacity_ctrl.capacity(), std::distance(first, last)]]</code>. </p></td>
 601 </tr>
 602 <tr>
 603 <td><p><span class="term">Throws:</span></p></td>
 604 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 605 </tr>
 606 </tbody>
 607 </table></div>
 608 </li>
 609 <li class="listitem">
 610 <pre class="literallayout"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
 611 <a name="idp32305904-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span> cb<span class="special">)</span><span class="special">;</span></pre>The assign operator. <p>Makes this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to become a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>.
 612
 613
 614 </p>
 615 <p><b>Exception Safety.&#160;</b>Strong. </p>
 616 <p>
 617 </p>
 618 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
 619 <p>
 620 </p>
 621 <p><b>Complexity.&#160;</b>Linear (in the size of <code class="computeroutput">cb</code>). </p>
 622 <p>
 623 </p>
 624 <p><span class="bold"><strong>See Also:</strong></span></p>
 625 <p><code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p>
 626 <p>
 627 </p>
 628 <div class="variablelist"><table border="0" class="variablelist compact">
 629 <colgroup>
 630 <col align="left" valign="top">
 631 <col>
 632 </colgroup>
 633 <tbody>
 634 <tr>
 635 <td><p><span class="term">Parameters:</span></p></td>
 636 <td><div class="variablelist"><table border="0" class="variablelist compact">
 637 <colgroup>
 638 <col align="left" valign="top">
 639 <col>
 640 </colgroup>
 641 <tbody><tr>
 642 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 643 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> to be copied. </p></td>
 644 </tr></tbody>
 645 </table></div></td>
 646 </tr>
 647 <tr>
 648 <td><p><span class="term">Postconditions:</span></p></td>
 649 <td><p><code class="computeroutput">*this == cb</code><br>
 650 <br>
 651  The amount of allocated memory in the internal buffer is <code class="computeroutput">cb.size()</code>. </p></td>
 652 </tr>
 653 <tr>
 654 <td><p><span class="term">Throws:</span></p></td>
 655 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 656 </tr>
 657 </tbody>
 658 </table></div>
 659 </li>
 660 <li class="listitem">
 661 <pre class="literallayout"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
 662 <a name="idp32322240-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Move assigns content of <code class="computeroutput">cb</code> to <code class="computeroutput">*this</code>, leaving <code class="computeroutput">cb</code> empty. <p>
 663
 664
 665
 666 </p>
 667 <p><b>Complexity.&#160;</b>Constant. </p>
 668 <p>
 669 </p>
 670 <div class="variablelist"><table border="0" class="variablelist compact">
 671 <colgroup>
 672 <col align="left" valign="top">
 673 <col>
 674 </colgroup>
 675 <tbody>
 676 <tr>
 677 <td><p><span class="term">Parameters:</span></p></td>
 678 <td><div class="variablelist"><table border="0" class="variablelist compact">
 679 <colgroup>
 680 <col align="left" valign="top">
 681 <col>
 682 </colgroup>
 683 <tbody><tr>
 684 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 685 <td><p><code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to 'steal' value from. </p></td>
 686 </tr></tbody>
 687 </table></div></td>
 688 </tr>
 689 <tr>
 690 <td><p><span class="term">Requires:</span></p></td>
 691 <td><p>C++ compiler with rvalue references support. </p></td>
 692 </tr>
 693 <tr>
 694 <td><p><span class="term">Postconditions:</span></p></td>
 695 <td><p><code class="computeroutput">cb.empty()</code> </p></td>
 696 </tr>
 697 <tr>
 698 <td><p><span class="term">Throws:</span></p></td>
 699 <td>Nothing. </td>
 700 </tr>
 701 </tbody>
 702 </table></div>
 703 </li>
 704 </ol></div>
 705 </div>
 706 <div class="refsect2">
 707 <a name="idp146846544"></a><h3>
 708 <a name="idp31516928-bb"></a><code class="computeroutput">circular_buffer_space_optimized</code> public member functions</h3>
 709 <div class="orderedlist"><ol class="orderedlist" type="1">
 710 <li class="listitem">
 711 <pre class="literallayout"><span class="keyword">bool</span> <a name="idp31517488-bb"></a><span class="identifier">full</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Is the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> full? <p>
 712
 713 </p>
 714 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 715 <p>
 716 </p>
 717 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 718 <p>
 719 </p>
 720 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
 721 <p>
 722 </p>
 723 <p><span class="bold"><strong>See Also:</strong></span></p>
 724 <p><code class="computeroutput">empty()</code> </p>
 725 <p>
 726 </p>
 727 <div class="variablelist"><table border="0" class="variablelist compact">
 728 <colgroup>
 729 <col align="left" valign="top">
 730 <col>
 731 </colgroup>
 732 <tbody>
 733 <tr>
 734 <td><p><span class="term">Returns:</span></p></td>
 735 <td><p><code class="computeroutput">true</code> if the number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> equals the capacity of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>; <code class="computeroutput">false</code> otherwise. </p></td>
 736 </tr>
 737 <tr>
 738 <td><p><span class="term">Throws:</span></p></td>
 739 <td>Nothing. </td>
 740 </tr>
 741 </tbody>
 742 </table></div>
 743 </li>
 744 <li class="listitem">
 745 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idp31528784-bb"></a><span class="identifier">reserve</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the maximum number of elements which can be inserted into the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> without overwriting any of already stored elements. <p>
 746
 747 </p>
 748 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 749 <p>
 750 </p>
 751 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 752 <p>
 753 </p>
 754 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
 755 <p>
 756 </p>
 757 <p><span class="bold"><strong>See Also:</strong></span></p>
 758 <p><code class="computeroutput">capacity()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code> </p>
 759 <p>
 760 </p>
 761 <div class="variablelist"><table border="0" class="variablelist compact">
 762 <colgroup>
 763 <col align="left" valign="top">
 764 <col>
 765 </colgroup>
 766 <tbody>
 767 <tr>
 768 <td><p><span class="term">Returns:</span></p></td>
 769 <td><p><code class="computeroutput">capacity().capacity() - size()</code> </p></td>
 770 </tr>
 771 <tr>
 772 <td><p><span class="term">Throws:</span></p></td>
 773 <td>Nothing. </td>
 774 </tr>
 775 </tbody>
 776 </table></div>
 777 </li>
 778 <li class="listitem">
 779 <pre class="literallayout"><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> <a name="idp31538816-bb"></a><span class="identifier">capacity</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p>
 780
 781 </p>
 782 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 783 <p>
 784 </p>
 785 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 786 <p>
 787 </p>
 788 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
 789 <p>
 790 </p>
 791 <p><span class="bold"><strong>See Also:</strong></span></p>
 792 <p><code class="computeroutput">reserve()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">set_capacity(const capacity_type&amp;)</code> </p>
 793 <p>
 794 </p>
 795 <div class="variablelist"><table border="0" class="variablelist compact">
 796 <colgroup>
 797 <col align="left" valign="top">
 798 <col>
 799 </colgroup>
 800 <tbody>
 801 <tr>
 802 <td><p><span class="term">Returns:</span></p></td>
 803 <td><p>The capacity controller representing the maximum number of elements which can be stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> and the minimal allocated size of the internal buffer. </p></td>
 804 </tr>
 805 <tr>
 806 <td><p><span class="term">Throws:</span></p></td>
 807 <td>Nothing. </td>
 808 </tr>
 809 </tbody>
 810 </table></div>
 811 </li>
 812 <li class="listitem">
 813 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31549952-bb"></a><span class="identifier">set_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">)</span><span class="special">;</span></pre>Change the capacity (and the minimal guaranteed amount of allocated memory) of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p>
 814
 815
 816 </p>
 817 <p><b>Exception Safety.&#160;</b>Strong. </p>
 818 <p>
 819 </p>
 820 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
 821 <p>
 822 </p>
 823 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[size(), capacity_ctrl.capacity()]</code>). </p>
 824 <p>
 825 </p>
 826 <div class="note"><table border="0" summary="Note">
 827 <tr>
 828 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
 829 <th align="left">Note</th>
 830 </tr>
 831 <tr><td align="left" valign="top"><p>To explicitly clear the extra allocated memory use the <span class="bold"><strong>shrink-to-fit</strong></span> technique:<br>
 832 <br>
 833  <code class="computeroutput">boost::circular_buffer_space_optimized&lt;int&gt; cb(1000);<br>
 834  ...<br>
 835  boost::circular_buffer_space_optimized&lt;int&gt;(cb).swap(cb);</code><br>
 836 <br>
 837  For more information about the shrink-to-fit technique in STL see <a href="http://www.gotw.ca/gotw/054.htm" target="_top">http://www.gotw.ca/gotw/054.htm</a>. </p></td></tr>
 838 </table></div>
 839 <p>
 840 </p>
 841 <p><span class="bold"><strong>See Also:</strong></span></p>
 842 <p><code class="computeroutput">rset_capacity(const capacity_type&amp;)</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p>
 843 <p>
 844 </p>
 845 <div class="variablelist"><table border="0" class="variablelist compact">
 846 <colgroup>
 847 <col align="left" valign="top">
 848 <col>
 849 </colgroup>
 850 <tbody>
 851 <tr>
 852 <td><p><span class="term">Parameters:</span></p></td>
 853 <td><div class="variablelist"><table border="0" class="variablelist compact">
 854 <colgroup>
 855 <col align="left" valign="top">
 856 <col>
 857 </colgroup>
 858 <tbody><tr>
 859 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 860 <td><p>The new capacity controller. </p></td>
 861 </tr></tbody>
 862 </table></div></td>
 863 </tr>
 864 <tr>
 865 <td><p><span class="term">Postconditions:</span></p></td>
 866 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() &lt;= capacity_ctrl.capacity()</code><br>
 867 <br>
 868  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - capacity_ctrl.capacity()]</code> <span class="bold"><strong>last</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">capacity_ctrl.capacity()</code>.<br>
 869 <br>
 870  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></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 class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td>
 871 </tr>
 872 <tr>
 873 <td><p><span class="term">Throws:</span></p></td>
 874 <td>An allocation error if memory is exhausted, (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
 875 </tr>
 876 </tbody>
 877 </table></div>
 878 </li>
 879 <li class="listitem">
 880 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31572144-bb"></a><span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> new_size<span class="special">,</span> <span class="identifier">param_value_type</span> item <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Change the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p>
 881
 882
 883 </p>
 884 <p><b>Exception Safety.&#160;</b>Basic. </p>
 885 <p>
 886 </p>
 887 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
 888 <p>
 889 </p>
 890 <p><b>Complexity.&#160;</b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
 891 <p>
 892 </p>
 893 <p><span class="bold"><strong>See Also:</strong></span></p>
 894 <p><code class="computeroutput">rresize(size_type, const_reference)</code>, <code class="computeroutput">set_capacity(const capacity_type&amp;)</code> </p>
 895 <p>
 896 </p>
 897 <div class="variablelist"><table border="0" class="variablelist compact">
 898 <colgroup>
 899 <col align="left" valign="top">
 900 <col>
 901 </colgroup>
 902 <tbody>
 903 <tr>
 904 <td><p><span class="term">Parameters:</span></p></td>
 905 <td><div class="variablelist"><table border="0" class="variablelist compact">
 906 <colgroup>
 907 <col align="left" valign="top">
 908 <col>
 909 </colgroup>
 910 <tbody>
 911 <tr>
 912 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
 913 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with in order to gain the requested size. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
 914 </tr>
 915 <tr>
 916 <td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td>
 917 <td><p>The new size. </p></td>
 918 </tr>
 919 </tbody>
 920 </table></div></td>
 921 </tr>
 922 <tr>
 923 <td><p><span class="term">Postconditions:</span></p></td>
 924 <td><p><code class="computeroutput">size() == new_size &amp;&amp; capacity().capacity() &gt;= new_size</code><br>
 925 <br>
 926  If the new size is greater than the current size, copies of <code class="computeroutput">item</code> will be inserted at the <span class="bold"><strong>back</strong></span> of the of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></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 class="computeroutput">new_size</code>.<br>
 927 <br>
 928  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new size then number of <code class="computeroutput">[size() - new_size]</code> <span class="bold"><strong>last</strong></span> elements will be removed. (The capacity will remain unchanged.)<br>
 929 <br>
 930  The amount of allocated memory in the internal buffer may be accommodated as necessary. </p></td>
 931 </tr>
 932 <tr>
 933 <td><p><span class="term">Throws:</span></p></td>
 934 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
 935 </tr>
 936 </tbody>
 937 </table></div>
 938 </li>
 939 <li class="listitem">
 940 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31594080-bb"></a><span class="identifier">rset_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">)</span><span class="special">;</span></pre>Change the capacity (and the minimal guaranteed amount of allocated memory) of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p>
 941
 942
 943 </p>
 944 <p><b>Exception Safety.&#160;</b>Strong. </p>
 945 <p>
 946 </p>
 947 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
 948 <p>
 949 </p>
 950 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[size(), capacity_ctrl.capacity()]</code>). </p>
 951 <p>
 952 </p>
 953 <p><span class="bold"><strong>See Also:</strong></span></p>
 954 <p><code class="computeroutput">set_capacity(const capacity_type&amp;)</code>, <code class="computeroutput">rresize(size_type, const_reference)</code> </p>
 955 <p>
 956 </p>
 957 <div class="variablelist"><table border="0" class="variablelist compact">
 958 <colgroup>
 959 <col align="left" valign="top">
 960 <col>
 961 </colgroup>
 962 <tbody>
 963 <tr>
 964 <td><p><span class="term">Parameters:</span></p></td>
 965 <td><div class="variablelist"><table border="0" class="variablelist compact">
 966 <colgroup>
 967 <col align="left" valign="top">
 968 <col>
 969 </colgroup>
 970 <tbody><tr>
 971 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
 972 <td><p>The new capacity controller. </p></td>
 973 </tr></tbody>
 974 </table></div></td>
 975 </tr>
 976 <tr>
 977 <td><p><span class="term">Postconditions:</span></p></td>
 978 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() &lt;= capacity_ctrl</code><br>
 979 <br>
 980  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - capacity_ctrl.capacity()]</code> <span class="bold"><strong>first</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">capacity_ctrl.capacity()</code>.<br>
 981 <br>
 982  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></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 class="computeroutput">capacity_ctrl.min_capacity()</code>. </p></td>
 983 </tr>
 984 <tr>
 985 <td><p><span class="term">Throws:</span></p></td>
 986 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
 987 </tr>
 988 </tbody>
 989 </table></div>
 990 </li>
 991 <li class="listitem">
 992 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31612032-bb"></a><span class="identifier">rresize</span><span class="special">(</span><span class="identifier">size_type</span> new_size<span class="special">,</span> <span class="identifier">param_value_type</span> item <span class="special">=</span> <span class="identifier">value_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>Change the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>. <p>
 993
 994
 995 </p>
 996 <p><b>Exception Safety.&#160;</b>Basic. </p>
 997 <p>
 998 </p>
 999 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1000 <p>
1001 </p>
1002 <p><b>Complexity.&#160;</b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1003 <p>
1004 </p>
1005 <p><span class="bold"><strong>See Also:</strong></span></p>
1006 <p><code class="computeroutput">resize(size_type, const_reference)</code>, <code class="computeroutput">rset_capacity(const capacity_type&amp;)</code> </p>
1007 <p>
1008 </p>
1009 <div class="variablelist"><table border="0" class="variablelist compact">
1010 <colgroup>
1011 <col align="left" valign="top">
1012 <col>
1013 </colgroup>
1014 <tbody>
1015 <tr>
1016 <td><p><span class="term">Parameters:</span></p></td>
1017 <td><div class="variablelist"><table border="0" class="variablelist compact">
1018 <colgroup>
1019 <col align="left" valign="top">
1020 <col>
1021 </colgroup>
1022 <tbody>
1023 <tr>
1024 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1025 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with in order to gain the requested size. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
1026 </tr>
1027 <tr>
1028 <td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td>
1029 <td><p>The new size. </p></td>
1030 </tr>
1031 </tbody>
1032 </table></div></td>
1033 </tr>
1034 <tr>
1035 <td><p><span class="term">Postconditions:</span></p></td>
1036 <td><p><code class="computeroutput">size() == new_size &amp;&amp; capacity().capacity() &gt;= new_size</code><br>
1037 <br>
1038  If the new size is greater than the current size, copies of <code class="computeroutput">item</code> will be inserted at the <span class="bold"><strong>front</strong></span> of the of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></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 class="computeroutput">new_size</code>.<br>
1039 <br>
1040  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is greater than the desired new size then number of <code class="computeroutput">[size() - new_size]</code> <span class="bold"><strong>first</strong></span> elements will be removed. (The capacity will remain unchanged.)<br>
1041 <br>
1042  The amount of allocated memory in the internal buffer may be accommodated as necessary. </p></td>
1043 </tr>
1044 <tr>
1045 <td><p><span class="term">Throws:</span></p></td>
1046 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
1047 </tr>
1048 </tbody>
1049 </table></div>
1050 </li>
1051 <li class="listitem">
1052 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31633968-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Assign <code class="computeroutput">n</code> items into the space optimized circular buffer. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>.
1053
1054
1055 </p>
1056 <p><b>Exception Safety.&#160;</b>Basic. </p>
1057 <p>
1058 </p>
1059 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1060 <p>
1061 </p>
1062 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
1063 <p>
1064 </p>
1065 <p><span class="bold"><strong>See Also:</strong></span></p>
1066 <p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p>
1067 <p>
1068 </p>
1069 <div class="variablelist"><table border="0" class="variablelist compact">
1070 <colgroup>
1071 <col align="left" valign="top">
1072 <col>
1073 </colgroup>
1074 <tbody>
1075 <tr>
1076 <td><p><span class="term">Parameters:</span></p></td>
1077 <td><div class="variablelist"><table border="0" class="variablelist compact">
1078 <colgroup>
1079 <col align="left" valign="top">
1080 <col>
1081 </colgroup>
1082 <tbody>
1083 <tr>
1084 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1085 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
1086 </tr>
1087 <tr>
1088 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
1089 <td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
1090 </tr>
1091 </tbody>
1092 </table></div></td>
1093 </tr>
1094 <tr>
1095 <td><p><span class="term">Postconditions:</span></p></td>
1096 <td><p><code class="computeroutput">capacity().capacity() == n &amp;&amp; capacity().min_capacity() == 0 &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1] == item</code><br>
1097 <br>
1098  The amount of allocated memory in the internal buffer is <code class="computeroutput">n</code>. </p></td>
1099 </tr>
1100 <tr>
1101 <td><p><span class="term">Throws:</span></p></td>
1102 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
1103 </tr>
1104 </tbody>
1105 </table></div>
1106 </li>
1107 <li class="listitem">
1108 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31652448-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Assign <code class="computeroutput">n</code> items into the space optimized circular buffer specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be set to the specified value and the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>.
1109
1110
1111
1112 </p>
1113 <p><b>Exception Safety.&#160;</b>Basic. </p>
1114 <p>
1115 </p>
1116 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1117 <p>
1118 </p>
1119 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
1120 <p>
1121 </p>
1122 <p><span class="bold"><strong>See Also:</strong></span></p>
1123 <p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p>
1124 <p>
1125 </p>
1126 <div class="variablelist"><table border="0" class="variablelist compact">
1127 <colgroup>
1128 <col align="left" valign="top">
1129 <col>
1130 </colgroup>
1131 <tbody>
1132 <tr>
1133 <td><p><span class="term">Parameters:</span></p></td>
1134 <td><div class="variablelist"><table border="0" class="variablelist compact">
1135 <colgroup>
1136 <col align="left" valign="top">
1137 <col>
1138 </colgroup>
1139 <tbody>
1140 <tr>
1141 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
1142 <td><p>The new capacity controller. </p></td>
1143 </tr>
1144 <tr>
1145 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1146 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
1147 </tr>
1148 <tr>
1149 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
1150 <td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be filled with. </p></td>
1151 </tr>
1152 </tbody>
1153 </table></div></td>
1154 </tr>
1155 <tr>
1156 <td><p><span class="term">Requires:</span></p></td>
1157 <td><p><code class="computeroutput">capacity_ctrl.capacity() &gt;= n</code> </p></td>
1158 </tr>
1159 <tr>
1160 <td><p><span class="term">Postconditions:</span></p></td>
1161 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1] == item </code><br>
1162 <br>
1163  The amount of allocated memory will be <code class="computeroutput">max[n, capacity_ctrl.min_capacity()]</code>. </p></td>
1164 </tr>
1165 <tr>
1166 <td><p><span class="term">Throws:</span></p></td>
1167 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
1168 </tr>
1169 </tbody>
1170 </table></div>
1171 </li>
1172 <li class="listitem">
1173 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
1174   <span class="keyword">void</span> <a name="idp31673680-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the space optimized circular buffer. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with copies of elements from the specified range.
1175
1176
1177
1178 </p>
1179 <p><b>Exception Safety.&#160;</b>Basic. </p>
1180 <p>
1181 </p>
1182 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1183 <p>
1184 </p>
1185 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p>
1186 <p>
1187 </p>
1188 <p><span class="bold"><strong>See Also:</strong></span></p>
1189 <p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, InputIterator, InputIterator)</code> </p>
1190 <p>
1191 </p>
1192 <div class="variablelist"><table border="0" class="variablelist compact">
1193 <colgroup>
1194 <col align="left" valign="top">
1195 <col>
1196 </colgroup>
1197 <tbody>
1198 <tr>
1199 <td><p><span class="term">Parameters:</span></p></td>
1200 <td><div class="variablelist"><table border="0" class="variablelist compact">
1201 <colgroup>
1202 <col align="left" valign="top">
1203 <col>
1204 </colgroup>
1205 <tbody>
1206 <tr>
1207 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
1208 <td><p>The beginning of the range to be copied. </p></td>
1209 </tr>
1210 <tr>
1211 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
1212 <td><p>The end of the range to be copied. </p></td>
1213 </tr>
1214 </tbody>
1215 </table></div></td>
1216 </tr>
1217 <tr>
1218 <td><p><span class="term">Requires:</span></p></td>
1219 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
1220  <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
1221 </tr>
1222 <tr>
1223 <td><p><span class="term">Postconditions:</span></p></td>
1224 <td><p><code class="computeroutput">capacity().capacity() == std::distance(first, last) &amp;&amp; capacity().min_capacity() == 0 &amp;&amp; size() == 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>
1225 <br>
1226  The amount of allocated memory in the internal buffer is <code class="computeroutput">std::distance(first, last)</code>. </p></td>
1227 </tr>
1228 <tr>
1229 <td><p><span class="term">Throws:</span></p></td>
1230 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td>
1231 </tr>
1232 </tbody>
1233 </table></div>
1234 </li>
1235 <li class="listitem">
1236 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
1237   <span class="keyword">void</span> <a name="idp31693824-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> capacity_ctrl<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span>
1238               <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the space optimized circular buffer specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be set to the specified value and the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> will be removed and replaced with copies of elements from the specified range.
1239
1240
1241
1242 </p>
1243 <p><b>Exception Safety.&#160;</b>Basic. </p>
1244 <p>
1245 </p>
1246 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1247 <p>
1248 </p>
1249 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[capacity_ctrl.capacity(), std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p>
1250 <p>
1251 </p>
1252 <p><span class="bold"><strong>See Also:</strong></span></p>
1253 <p><code class="computeroutput">operator=</code>, <code class="computeroutput">assign(size_type, const_reference)</code>, <code class="computeroutput">assign(capacity_type, size_type, const_reference)</code>, <code class="computeroutput">assign(InputIterator, InputIterator)</code> </p>
1254 <p>
1255 </p>
1256 <div class="variablelist"><table border="0" class="variablelist compact">
1257 <colgroup>
1258 <col align="left" valign="top">
1259 <col>
1260 </colgroup>
1261 <tbody>
1262 <tr>
1263 <td><p><span class="term">Parameters:</span></p></td>
1264 <td><div class="variablelist"><table border="0" class="variablelist compact">
1265 <colgroup>
1266 <col align="left" valign="top">
1267 <col>
1268 </colgroup>
1269 <tbody>
1270 <tr>
1271 <td><p><span class="term"><code class="computeroutput">capacity_ctrl</code></span></p></td>
1272 <td><p>The new capacity controller. </p></td>
1273 </tr>
1274 <tr>
1275 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
1276 <td><p>The beginning of the range to be copied. </p></td>
1277 </tr>
1278 <tr>
1279 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
1280 <td><p>The end of the range to be copied. </p></td>
1281 </tr>
1282 </tbody>
1283 </table></div></td>
1284 </tr>
1285 <tr>
1286 <td><p><span class="term">Requires:</span></p></td>
1287 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
1288  <code class="computeroutput">first</code> and <code class="computeroutput">last</code> have to meet the requirements of <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
1289 </tr>
1290 <tr>
1291 <td><p><span class="term">Postconditions:</span></p></td>
1292 <td><p><code class="computeroutput">capacity() == capacity_ctrl &amp;&amp; size() &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>
1293 <br>
1294  If the number of items to be copied from the range <code class="computeroutput">[first, last)</code> is greater than the specified <code class="computeroutput">capacity</code> then only elements from the range <code class="computeroutput">[last - capacity, last)</code> will be copied.<br>
1295 <br>
1296  The amount of allocated memory in the internal buffer is <code class="computeroutput">max[std::distance(first, last), capacity_ctrl.min_capacity()]</code>. </p></td>
1297 </tr>
1298 <tr>
1299 <td><p><span class="term">Throws:</span></p></td>
1300 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept and <code class="computeroutput">InputIterator</code> is a move iterator. </td>
1301 </tr>
1302 </tbody>
1303 </table></div>
1304 </li>
1305 <li class="listitem">
1306 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31719696-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&amp;</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Swap the contents of two space-optimized circular-buffers. <p>
1307
1308
1309 </p>
1310 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1311 <p>
1312 </p>
1313 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators of both <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></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 __debug_support off by defining macro BOOST_CB_DISABLE_DEBUG, otherwise an assertion will report an error if such invalidated iterator is used.) </p>
1314 <p>
1315 </p>
1316 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1317 <p>
1318 </p>
1319 <p><span class="bold"><strong>See Also:</strong></span></p>
1320 <p><code class="computeroutput">swap(circular_buffer&lt;T, Alloc&gt;&amp;, circular_buffer&lt;T, Alloc&gt;&amp;)</code>, <code class="computeroutput">swap(circular_buffer_space_optimized&lt;T, Alloc&gt;&amp;, circular_buffer_space_optimized&lt;T, Alloc&gt;&amp;)</code> </p>
1321 <p>
1322 </p>
1323 <div class="variablelist"><table border="0" class="variablelist compact">
1324 <colgroup>
1325 <col align="left" valign="top">
1326 <col>
1327 </colgroup>
1328 <tbody>
1329 <tr>
1330 <td><p><span class="term">Parameters:</span></p></td>
1331 <td><div class="variablelist"><table border="0" class="variablelist compact">
1332 <colgroup>
1333 <col align="left" valign="top">
1334 <col>
1335 </colgroup>
1336 <tbody><tr>
1337 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
1338 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> whose content will be swapped. </p></td>
1339 </tr></tbody>
1340 </table></div></td>
1341 </tr>
1342 <tr>
1343 <td><p><span class="term">Postconditions:</span></p></td>
1344 <td><p><code class="computeroutput">this</code> contains elements of <code class="computeroutput">cb</code> and vice versa; the capacity and the amount of allocated memory in the internal buffer of <code class="computeroutput">this</code> equal to the capacity and the amount of allocated memory of <code class="computeroutput">cb</code> and vice versa. </p></td>
1345 </tr>
1346 <tr>
1347 <td><p><span class="term">Throws:</span></p></td>
1348 <td>Nothing. </td>
1349 </tr>
1350 </tbody>
1351 </table></div>
1352 </li>
1353 <li class="listitem">
1354 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31733424-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p>
1355
1356
1357 </p>
1358 <p><b>Exception Safety.&#160;</b>Basic. </p>
1359 <p>
1360 </p>
1361 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1362 <p>
1363 </p>
1364 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1365 <p>
1366 </p>
1367 <p><span class="bold"><strong>See Also:</strong></span></p>
1368 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1369 <p>
1370 </p>
1371 <div class="variablelist"><table border="0" class="variablelist compact">
1372 <colgroup>
1373 <col align="left" valign="top">
1374 <col>
1375 </colgroup>
1376 <tbody>
1377 <tr>
1378 <td><p><span class="term">Parameters:</span></p></td>
1379 <td><div class="variablelist"><table border="0" class="variablelist compact">
1380 <colgroup>
1381 <col align="left" valign="top">
1382 <col>
1383 </colgroup>
1384 <tbody><tr>
1385 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1386 <td><p>The element to be inserted. </p></td>
1387 </tr></tbody>
1388 </table></div></td>
1389 </tr>
1390 <tr>
1391 <td><p><span class="term">Postconditions:</span></p></td>
1392 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
1393  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1394 <br>
1395  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1396 </tr>
1397 <tr>
1398 <td><p><span class="term">Throws:</span></p></td>
1399 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
1400 </tr>
1401 </tbody>
1402 </table></div>
1403 </li>
1404 <li class="listitem">
1405 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31748496-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p>
1406
1407
1408 </p>
1409 <p><b>Exception Safety.&#160;</b>Basic. </p>
1410 <p>
1411 </p>
1412 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1413 <p>
1414 </p>
1415 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1416 <p>
1417 </p>
1418 <p><span class="bold"><strong>See Also:</strong></span></p>
1419 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1420 <p>
1421 </p>
1422 <div class="variablelist"><table border="0" class="variablelist compact">
1423 <colgroup>
1424 <col align="left" valign="top">
1425 <col>
1426 </colgroup>
1427 <tbody>
1428 <tr>
1429 <td><p><span class="term">Parameters:</span></p></td>
1430 <td><div class="variablelist"><table border="0" class="variablelist compact">
1431 <colgroup>
1432 <col align="left" valign="top">
1433 <col>
1434 </colgroup>
1435 <tbody><tr>
1436 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1437 <td><p>The element to be inserted. </p></td>
1438 </tr></tbody>
1439 </table></div></td>
1440 </tr>
1441 <tr>
1442 <td><p><span class="term">Postconditions:</span></p></td>
1443 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
1444  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1445 <br>
1446  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1447 </tr>
1448 <tr>
1449 <td><p><span class="term">Throws:</span></p></td>
1450 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
1451 </tr>
1452 </tbody>
1453 </table></div>
1454 </li>
1455 <li class="listitem">
1456 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31763104-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new element at the end of the space optimized circular buffer. <p>
1457
1458 </p>
1459 <p><b>Exception Safety.&#160;</b>Basic. </p>
1460 <p>
1461 </p>
1462 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1463 <p>
1464 </p>
1465 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1466 <p>
1467 </p>
1468 <p><span class="bold"><strong>See Also:</strong></span></p>
1469 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1470 <p>
1471 </p>
1472 <div class="variablelist"><table border="0" class="variablelist compact">
1473 <colgroup>
1474 <col align="left" valign="top">
1475 <col>
1476 </colgroup>
1477 <tbody>
1478 <tr>
1479 <td><p><span class="term">Postconditions:</span></p></td>
1480 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
1481  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1482 <br>
1483  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1484 </tr>
1485 <tr>
1486 <td><p><span class="term">Throws:</span></p></td>
1487 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
1488 </tr>
1489 </tbody>
1490 </table></div>
1491 </li>
1492 <li class="listitem">
1493 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31777952-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p>
1494
1495
1496 </p>
1497 <p><b>Exception Safety.&#160;</b>Basic. </p>
1498 <p>
1499 </p>
1500 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1501 <p>
1502 </p>
1503 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1504 <p>
1505 </p>
1506 <p><span class="bold"><strong>See Also:</strong></span></p>
1507 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1508 <p>
1509 </p>
1510 <div class="variablelist"><table border="0" class="variablelist compact">
1511 <colgroup>
1512 <col align="left" valign="top">
1513 <col>
1514 </colgroup>
1515 <tbody>
1516 <tr>
1517 <td><p><span class="term">Parameters:</span></p></td>
1518 <td><div class="variablelist"><table border="0" class="variablelist compact">
1519 <colgroup>
1520 <col align="left" valign="top">
1521 <col>
1522 </colgroup>
1523 <tbody><tr>
1524 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1525 <td><p>The element to be inserted. </p></td>
1526 </tr></tbody>
1527 </table></div></td>
1528 </tr>
1529 <tr>
1530 <td><p><span class="term">Postconditions:</span></p></td>
1531 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
1532  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1533 <br>
1534  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1535 </tr>
1536 <tr>
1537 <td><p><span class="term">Throws:</span></p></td>
1538 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. </td>
1539 </tr>
1540 </tbody>
1541 </table></div>
1542 </li>
1543 <li class="listitem">
1544 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31793024-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p>
1545
1546
1547 </p>
1548 <p><b>Exception Safety.&#160;</b>Basic. </p>
1549 <p>
1550 </p>
1551 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1552 <p>
1553 </p>
1554 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1555 <p>
1556 </p>
1557 <p><span class="bold"><strong>See Also:</strong></span></p>
1558 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1559 <p>
1560 </p>
1561 <div class="variablelist"><table border="0" class="variablelist compact">
1562 <colgroup>
1563 <col align="left" valign="top">
1564 <col>
1565 </colgroup>
1566 <tbody>
1567 <tr>
1568 <td><p><span class="term">Parameters:</span></p></td>
1569 <td><div class="variablelist"><table border="0" class="variablelist compact">
1570 <colgroup>
1571 <col align="left" valign="top">
1572 <col>
1573 </colgroup>
1574 <tbody><tr>
1575 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1576 <td><p>The element to be inserted. </p></td>
1577 </tr></tbody>
1578 </table></div></td>
1579 </tr>
1580 <tr>
1581 <td><p><span class="term">Postconditions:</span></p></td>
1582 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
1583  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1584 <br>
1585  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1586 </tr>
1587 <tr>
1588 <td><p><span class="term">Throws:</span></p></td>
1589 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
1590 </tr>
1591 </tbody>
1592 </table></div>
1593 </li>
1594 <li class="listitem">
1595 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31808544-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new element at the beginning of the space optimized circular buffer. <p>
1596
1597 </p>
1598 <p><b>Exception Safety.&#160;</b>Basic. </p>
1599 <p>
1600 </p>
1601 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1602 <p>
1603 </p>
1604 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1605 <p>
1606 </p>
1607 <p><span class="bold"><strong>See Also:</strong></span></p>
1608 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
1609 <p>
1610 </p>
1611 <div class="variablelist"><table border="0" class="variablelist compact">
1612 <colgroup>
1613 <col align="left" valign="top">
1614 <col>
1615 </colgroup>
1616 <tbody>
1617 <tr>
1618 <td><p><span class="term">Postconditions:</span></p></td>
1619 <td><p>if <code class="computeroutput">capacity().capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
1620  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1621 <br>
1622  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1623 </tr>
1624 <tr>
1625 <td><p><span class="term">Throws:</span></p></td>
1626 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
1627 </tr>
1628 </tbody>
1629 </table></div>
1630 </li>
1631 <li class="listitem">
1632 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31823392-bb"></a><span class="identifier">pop_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove the last element from the space optimized circular buffer. <p>
1633
1634
1635 </p>
1636 <p><b>Exception Safety.&#160;</b>Basic. </p>
1637 <p>
1638 </p>
1639 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1640 <p>
1641 </p>
1642 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1643 <p>
1644 </p>
1645 <p><span class="bold"><strong>See Also:</strong></span></p>
1646 <p><code class="computeroutput">pop_front()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p>
1647 <p>
1648 </p>
1649 <div class="variablelist"><table border="0" class="variablelist compact">
1650 <colgroup>
1651 <col align="left" valign="top">
1652 <col>
1653 </colgroup>
1654 <tbody>
1655 <tr>
1656 <td><p><span class="term">Requires:</span></p></td>
1657 <td><p><code class="computeroutput">!empty()</code> </p></td>
1658 </tr>
1659 <tr>
1660 <td><p><span class="term">Postconditions:</span></p></td>
1661 <td><p>The last element is removed from the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br>
1662 <br>
1663  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
1664 </tr>
1665 <tr>
1666 <td><p><span class="term">Throws:</span></p></td>
1667 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
1668 </tr>
1669 </tbody>
1670 </table></div>
1671 </li>
1672 <li class="listitem">
1673 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31836048-bb"></a><span class="identifier">pop_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove the first element from the space optimized circular buffer. <p>
1674
1675
1676 </p>
1677 <p><b>Exception Safety.&#160;</b>Basic. </p>
1678 <p>
1679 </p>
1680 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1681 <p>
1682 </p>
1683 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1684 <p>
1685 </p>
1686 <p><span class="bold"><strong>See Also:</strong></span></p>
1687 <p><code class="computeroutput">pop_back()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p>
1688 <p>
1689 </p>
1690 <div class="variablelist"><table border="0" class="variablelist compact">
1691 <colgroup>
1692 <col align="left" valign="top">
1693 <col>
1694 </colgroup>
1695 <tbody>
1696 <tr>
1697 <td><p><span class="term">Requires:</span></p></td>
1698 <td><p><code class="computeroutput">!empty()</code> </p></td>
1699 </tr>
1700 <tr>
1701 <td><p><span class="term">Postconditions:</span></p></td>
1702 <td><p>The first element is removed from the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br>
1703 <br>
1704  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
1705 </tr>
1706 <tr>
1707 <td><p><span class="term">Throws:</span></p></td>
1708 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
1709 </tr>
1710 </tbody>
1711 </table></div>
1712 </li>
1713 <li class="listitem">
1714 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp31848704-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p>
1715
1716
1717
1718
1719 </p>
1720 <p><b>Exception Safety.&#160;</b>Basic. </p>
1721 <p>
1722 </p>
1723 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1724 <p>
1725 </p>
1726 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1727 <p>
1728 </p>
1729 <p><span class="bold"><strong>See Also:</strong></span></p>
1730 <p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p>
1731 <p>
1732 </p>
1733 <div class="variablelist"><table border="0" class="variablelist compact">
1734 <colgroup>
1735 <col align="left" valign="top">
1736 <col>
1737 </colgroup>
1738 <tbody>
1739 <tr>
1740 <td><p><span class="term">Parameters:</span></p></td>
1741 <td><div class="variablelist"><table border="0" class="variablelist compact">
1742 <colgroup>
1743 <col align="left" valign="top">
1744 <col>
1745 </colgroup>
1746 <tbody>
1747 <tr>
1748 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1749 <td><p>The element to be inserted. </p></td>
1750 </tr>
1751 <tr>
1752 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
1753 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
1754 </tr>
1755 </tbody>
1756 </table></div></td>
1757 </tr>
1758 <tr>
1759 <td><p><span class="term">Requires:</span></p></td>
1760 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
1761 </tr>
1762 <tr>
1763 <td><p><span class="term">Postconditions:</span></p></td>
1764 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
1765  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1766 <br>
1767  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1768 </tr>
1769 <tr>
1770 <td><p><span class="term">Returns:</span></p></td>
1771 <td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
1772 </tr>
1773 <tr>
1774 <td><p><span class="term">Throws:</span></p></td>
1775 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
1776 </tr>
1777 </tbody>
1778 </table></div>
1779 </li>
1780 <li class="listitem">
1781 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp31872608-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p>
1782
1783
1784
1785
1786 </p>
1787 <p><b>Exception Safety.&#160;</b>Basic. </p>
1788 <p>
1789 </p>
1790 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1791 <p>
1792 </p>
1793 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1794 <p>
1795 </p>
1796 <p><span class="bold"><strong>See Also:</strong></span></p>
1797 <p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p>
1798 <p>
1799 </p>
1800 <div class="variablelist"><table border="0" class="variablelist compact">
1801 <colgroup>
1802 <col align="left" valign="top">
1803 <col>
1804 </colgroup>
1805 <tbody>
1806 <tr>
1807 <td><p><span class="term">Parameters:</span></p></td>
1808 <td><div class="variablelist"><table border="0" class="variablelist compact">
1809 <colgroup>
1810 <col align="left" valign="top">
1811 <col>
1812 </colgroup>
1813 <tbody>
1814 <tr>
1815 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1816 <td><p>The element to be inserted. </p></td>
1817 </tr>
1818 <tr>
1819 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
1820 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
1821 </tr>
1822 </tbody>
1823 </table></div></td>
1824 </tr>
1825 <tr>
1826 <td><p><span class="term">Requires:</span></p></td>
1827 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
1828 </tr>
1829 <tr>
1830 <td><p><span class="term">Postconditions:</span></p></td>
1831 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
1832  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1833 <br>
1834  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1835 </tr>
1836 <tr>
1837 <td><p><span class="term">Returns:</span></p></td>
1838 <td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
1839 </tr>
1840 <tr>
1841 <td><p><span class="term">Throws:</span></p></td>
1842 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
1843 </tr>
1844 </tbody>
1845 </table></div>
1846 </li>
1847 <li class="listitem">
1848 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp31896496-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Insert an element at the specified position. <p>
1849
1850
1851
1852
1853 </p>
1854 <p><b>Exception Safety.&#160;</b>Basic. </p>
1855 <p>
1856 </p>
1857 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1858 <p>
1859 </p>
1860 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
1861 <p>
1862 </p>
1863 <p><span class="bold"><strong>See Also:</strong></span></p>
1864 <p><code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p>
1865 <p>
1866 </p>
1867 <div class="variablelist"><table border="0" class="variablelist compact">
1868 <colgroup>
1869 <col align="left" valign="top">
1870 <col>
1871 </colgroup>
1872 <tbody>
1873 <tr>
1874 <td><p><span class="term">Parameters:</span></p></td>
1875 <td><div class="variablelist"><table border="0" class="variablelist compact">
1876 <colgroup>
1877 <col align="left" valign="top">
1878 <col>
1879 </colgroup>
1880 <tbody><tr>
1881 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
1882 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
1883 </tr></tbody>
1884 </table></div></td>
1885 </tr>
1886 <tr>
1887 <td><p><span class="term">Requires:</span></p></td>
1888 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
1889 </tr>
1890 <tr>
1891 <td><p><span class="term">Postconditions:</span></p></td>
1892 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
1893  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">begin()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
1894 <br>
1895  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1896 </tr>
1897 <tr>
1898 <td><p><span class="term">Returns:</span></p></td>
1899 <td><p>Iterator to the inserted element or <code class="computeroutput">begin()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
1900 </tr>
1901 <tr>
1902 <td><p><span class="term">Throws:</span></p></td>
1903 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
1904 </tr>
1905 </tbody>
1906 </table></div>
1907 </li>
1908 <li class="listitem">
1909 <pre class="literallayout"><span class="keyword">void</span> <a name="idp31919712-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code> at the specified position. <p>
1910
1911
1912
1913 </p>
1914 <p><b>Exception Safety.&#160;</b>Basic. </p>
1915 <p>
1916 </p>
1917 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
1918 <p>
1919 </p>
1920 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[capacity().capacity(), size() + n]</code>). </p>
1921 <p>
1922 </p>
1923 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
1924 <br>
1925  <code class="computeroutput">|1|2|3|4| | |</code><br>
1926  <code class="computeroutput">p ___^</code><br>
1927 <br>
1928 After inserting 5 elements at the position <code class="computeroutput">p</code>:<br>
1929 <br>
1930  <code class="computeroutput">insert(p, (size_t)5, 0);</code><br>
1931 <br>
1932 actually only 4 elements get inserted and elements <code class="computeroutput">1</code> and <code class="computeroutput">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>
1933 <br>
1934 <code class="computeroutput">|0|0|0|0|3|4|</code><br>
1935  <br>
1936 For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|0|0|0|0|0|3|4|</code>. </p>
1937 <p>
1938 </p>
1939 <p><span class="bold"><strong>See Also:</strong></span></p>
1940 <p><code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p>
1941 <p>
1942 </p>
1943 <div class="variablelist"><table border="0" class="variablelist compact">
1944 <colgroup>
1945 <col align="left" valign="top">
1946 <col>
1947 </colgroup>
1948 <tbody>
1949 <tr>
1950 <td><p><span class="term">Parameters:</span></p></td>
1951 <td><div class="variablelist"><table border="0" class="variablelist compact">
1952 <colgroup>
1953 <col align="left" valign="top">
1954 <col>
1955 </colgroup>
1956 <tbody>
1957 <tr>
1958 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
1959 <td><p>The element whose copies will be inserted. </p></td>
1960 </tr>
1961 <tr>
1962 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
1963 <td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td>
1964 </tr>
1965 <tr>
1966 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
1967 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td>
1968 </tr>
1969 </tbody>
1970 </table></div></td>
1971 </tr>
1972 <tr>
1973 <td><p><span class="term">Requires:</span></p></td>
1974 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
1975 </tr>
1976 <tr>
1977 <td><p><span class="term">Postconditions:</span></p></td>
1978 <td><p>The number of <code class="computeroutput">min[n, (pos - begin()) + reserve()]</code> elements will be inserted at the position <code class="computeroutput">pos</code>.<br>
1979 The number of <code class="computeroutput">min[pos - begin(), max[0, n - reserve()]]</code> elements will be overwritten at the beginning of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br>
1980 (See <span class="emphasis"><em>Example</em></span> for the explanation.)<br>
1981 <br>
1982  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
1983 </tr>
1984 <tr>
1985 <td><p><span class="term">Throws:</span></p></td>
1986 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
1987 </tr>
1988 </tbody>
1989 </table></div>
1990 </li>
1991 <li class="listitem">
1992 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
1993   <span class="keyword">void</span> <a name="idp31951152-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Insert the range <code class="computeroutput">[first, last)</code> at the specified position. <p>
1994
1995
1996
1997 </p>
1998 <p><b>Exception Safety.&#160;</b>Basic. </p>
1999 <p>
2000 </p>
2001 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2002 <p>
2003 </p>
2004 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">[size() + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity().capacity(), size() + std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p>
2005 <p>
2006 </p>
2007 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
2008 <br>
2009  <code class="computeroutput">|1|2|3|4| | |</code><br>
2010  <code class="computeroutput">p ___^</code><br>
2011 <br>
2012 After inserting a range of elements at the position <code class="computeroutput">p</code>:<br>
2013 <br>
2014  <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br>
2015 <code class="computeroutput">insert(p, array, array + 5);</code><br>
2016 <br>
2017  actually only elements <code class="computeroutput">6</code>, <code class="computeroutput">7</code>, <code class="computeroutput">8</code> and <code class="computeroutput">9</code> from the specified range get inserted and elements <code class="computeroutput">1</code> and <code class="computeroutput">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>
2018 <br>
2019 <code class="computeroutput">|6|7|8|9|3|4|</code><br>
2020 <br>
2021 For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|5|6|7|8|9|3|4|</code>. </p>
2022 <p>
2023 </p>
2024 <p><span class="bold"><strong>See Also:</strong></span></p>
2025 <p><code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code> </p>
2026 <p>
2027 </p>
2028 <div class="variablelist"><table border="0" class="variablelist compact">
2029 <colgroup>
2030 <col align="left" valign="top">
2031 <col>
2032 </colgroup>
2033 <tbody>
2034 <tr>
2035 <td><p><span class="term">Parameters:</span></p></td>
2036 <td><div class="variablelist"><table border="0" class="variablelist compact">
2037 <colgroup>
2038 <col align="left" valign="top">
2039 <col>
2040 </colgroup>
2041 <tbody>
2042 <tr>
2043 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2044 <td><p>The beginning of the range to be inserted. </p></td>
2045 </tr>
2046 <tr>
2047 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2048 <td><p>The end of the range to be inserted. </p></td>
2049 </tr>
2050 <tr>
2051 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2052 <td><p>An iterator specifying the position where the range will be inserted. </p></td>
2053 </tr>
2054 </tbody>
2055 </table></div></td>
2056 </tr>
2057 <tr>
2058 <td><p><span class="term">Requires:</span></p></td>
2059 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end.<br>
2060 Valid range <code class="computeroutput">[first, last)</code> where <code class="computeroutput">first</code> and <code class="computeroutput">last</code> meet the requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
2061 </tr>
2062 <tr>
2063 <td><p><span class="term">Postconditions:</span></p></td>
2064 <td><p>Elements from the range <code class="computeroutput">[first + max[0, distance(first, last) - (pos - begin()) - reserve()], last)</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
2065 The number of <code class="computeroutput">min[pos - begin(), max[0, distance(first, last) - reserve()]]</code> elements will be overwritten at the beginning of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br>
2066 (See <span class="emphasis"><em>Example</em></span> for the explanation.)<br>
2067 <br>
2068  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2069 </tr>
2070 <tr>
2071 <td><p><span class="term">Throws:</span></p></td>
2072 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
2073 </tr>
2074 </tbody>
2075 </table></div>
2076 </li>
2077 <li class="listitem">
2078 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp31988656-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p>
2079
2080
2081
2082
2083 </p>
2084 <p><b>Exception Safety.&#160;</b>Basic. </p>
2085 <p>
2086 </p>
2087 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2088 <p>
2089 </p>
2090 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2091 <p>
2092 </p>
2093 <p><span class="bold"><strong>See Also:</strong></span></p>
2094 <p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p>
2095 <p>
2096 </p>
2097 <div class="variablelist"><table border="0" class="variablelist compact">
2098 <colgroup>
2099 <col align="left" valign="top">
2100 <col>
2101 </colgroup>
2102 <tbody>
2103 <tr>
2104 <td><p><span class="term">Parameters:</span></p></td>
2105 <td><div class="variablelist"><table border="0" class="variablelist compact">
2106 <colgroup>
2107 <col align="left" valign="top">
2108 <col>
2109 </colgroup>
2110 <tbody>
2111 <tr>
2112 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2113 <td><p>The element to be inserted. </p></td>
2114 </tr>
2115 <tr>
2116 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2117 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
2118 </tr>
2119 </tbody>
2120 </table></div></td>
2121 </tr>
2122 <tr>
2123 <td><p><span class="term">Requires:</span></p></td>
2124 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
2125 </tr>
2126 <tr>
2127 <td><p><span class="term">Postconditions:</span></p></td>
2128 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
2129  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
2130 <br>
2131  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2132 </tr>
2133 <tr>
2134 <td><p><span class="term">Returns:</span></p></td>
2135 <td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
2136 </tr>
2137 <tr>
2138 <td><p><span class="term">Throws:</span></p></td>
2139 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
2140 </tr>
2141 </tbody>
2142 </table></div>
2143 </li>
2144 <li class="listitem">
2145 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32012544-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">rvalue_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p>
2146
2147
2148
2149
2150 </p>
2151 <p><b>Exception Safety.&#160;</b>Basic. </p>
2152 <p>
2153 </p>
2154 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2155 <p>
2156 </p>
2157 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2158 <p>
2159 </p>
2160 <p><span class="bold"><strong>See Also:</strong></span></p>
2161 <p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p>
2162 <p>
2163 </p>
2164 <div class="variablelist"><table border="0" class="variablelist compact">
2165 <colgroup>
2166 <col align="left" valign="top">
2167 <col>
2168 </colgroup>
2169 <tbody>
2170 <tr>
2171 <td><p><span class="term">Parameters:</span></p></td>
2172 <td><div class="variablelist"><table border="0" class="variablelist compact">
2173 <colgroup>
2174 <col align="left" valign="top">
2175 <col>
2176 </colgroup>
2177 <tbody>
2178 <tr>
2179 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2180 <td><p>The element to be inserted. </p></td>
2181 </tr>
2182 <tr>
2183 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2184 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
2185 </tr>
2186 </tbody>
2187 </table></div></td>
2188 </tr>
2189 <tr>
2190 <td><p><span class="term">Requires:</span></p></td>
2191 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
2192 </tr>
2193 <tr>
2194 <td><p><span class="term">Postconditions:</span></p></td>
2195 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
2196  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
2197 <br>
2198  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2199 </tr>
2200 <tr>
2201 <td><p><span class="term">Returns:</span></p></td>
2202 <td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
2203 </tr>
2204 <tr>
2205 <td><p><span class="term">Throws:</span></p></td>
2206 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
2207 </tr>
2208 </tbody>
2209 </table></div>
2210 </li>
2211 <li class="listitem">
2212 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32036416-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Insert an element before the specified position. <p>
2213
2214
2215
2216
2217 </p>
2218 <p><b>Exception Safety.&#160;</b>Basic. </p>
2219 <p>
2220 </p>
2221 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2222 <p>
2223 </p>
2224 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2225 <p>
2226 </p>
2227 <p><span class="bold"><strong>See Also:</strong></span></p>
2228 <p><code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p>
2229 <p>
2230 </p>
2231 <div class="variablelist"><table border="0" class="variablelist compact">
2232 <colgroup>
2233 <col align="left" valign="top">
2234 <col>
2235 </colgroup>
2236 <tbody>
2237 <tr>
2238 <td><p><span class="term">Parameters:</span></p></td>
2239 <td><div class="variablelist"><table border="0" class="variablelist compact">
2240 <colgroup>
2241 <col align="left" valign="top">
2242 <col>
2243 </colgroup>
2244 <tbody><tr>
2245 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2246 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
2247 </tr></tbody>
2248 </table></div></td>
2249 </tr>
2250 <tr>
2251 <td><p><span class="term">Requires:</span></p></td>
2252 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
2253 </tr>
2254 <tr>
2255 <td><p><span class="term">Postconditions:</span></p></td>
2256 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
2257  If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> is full and the <code class="computeroutput">pos</code> points to <code class="computeroutput">end()</code>, then the <code class="computeroutput">item</code> will not be inserted. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted.<br>
2258 <br>
2259  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2260 </tr>
2261 <tr>
2262 <td><p><span class="term">Returns:</span></p></td>
2263 <td><p>Iterator to the inserted element or <code class="computeroutput">end()</code> if the <code class="computeroutput">item</code> is not inserted. (See the <span class="emphasis"><em>Effect</em></span>.) </p></td>
2264 </tr>
2265 <tr>
2266 <td><p><span class="term">Throws:</span></p></td>
2267 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws or nothing if <code class="computeroutput">T::T(T&amp;&amp;)</code> is noexcept. </td>
2268 </tr>
2269 </tbody>
2270 </table></div>
2271 </li>
2272 <li class="listitem">
2273 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32059616-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span> <span class="identifier">param_value_type</span> item<span class="special">)</span><span class="special">;</span></pre>Insert <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code> before the specified position. <p>
2274
2275
2276
2277 </p>
2278 <p><b>Exception Safety.&#160;</b>Basic. </p>
2279 <p>
2280 </p>
2281 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2282 <p>
2283 </p>
2284 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[capacity().capacity(), size() + n]</code>). </p>
2285 <p>
2286 </p>
2287 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
2288 <br>
2289  <code class="computeroutput">|1|2|3|4| | |</code><br>
2290  <code class="computeroutput">p ___^</code><br>
2291 <br>
2292 After inserting 5 elements before the position <code class="computeroutput">p</code>:<br>
2293 <br>
2294  <code class="computeroutput">rinsert(p, (size_t)5, 0);</code><br>
2295 <br>
2296 actually only 4 elements get inserted and elements <code class="computeroutput">3</code> and <code class="computeroutput">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>
2297 <br>
2298 <code class="computeroutput">|1|2|0|0|0|0|</code><br>
2299  <br>
2300 For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|0|0|0|0|0|3|4|</code>. </p>
2301 <p>
2302 </p>
2303 <p><span class="bold"><strong>See Also:</strong></span></p>
2304 <p><code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, InputIterator, InputIterator)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p>
2305 <p>
2306 </p>
2307 <div class="variablelist"><table border="0" class="variablelist compact">
2308 <colgroup>
2309 <col align="left" valign="top">
2310 <col>
2311 </colgroup>
2312 <tbody>
2313 <tr>
2314 <td><p><span class="term">Parameters:</span></p></td>
2315 <td><div class="variablelist"><table border="0" class="variablelist compact">
2316 <colgroup>
2317 <col align="left" valign="top">
2318 <col>
2319 </colgroup>
2320 <tbody>
2321 <tr>
2322 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2323 <td><p>The element whose copies will be inserted. </p></td>
2324 </tr>
2325 <tr>
2326 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
2327 <td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td>
2328 </tr>
2329 <tr>
2330 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2331 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td>
2332 </tr>
2333 </tbody>
2334 </table></div></td>
2335 </tr>
2336 <tr>
2337 <td><p><span class="term">Requires:</span></p></td>
2338 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end. </p></td>
2339 </tr>
2340 <tr>
2341 <td><p><span class="term">Postconditions:</span></p></td>
2342 <td><p>The number of <code class="computeroutput">min[n, (end() - pos) + reserve()]</code> elements will be inserted before the position <code class="computeroutput">pos</code>.<br>
2343 The number of <code class="computeroutput">min[end() - pos, max[0, n - reserve()]]</code> elements will be overwritten at the end of the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code>.<br>
2344 (See <span class="emphasis"><em>Example</em></span> for the explanation.)<br>
2345 <br>
2346  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2347 </tr>
2348 <tr>
2349 <td><p><span class="term">Throws:</span></p></td>
2350 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
2351 </tr>
2352 </tbody>
2353 </table></div>
2354 </li>
2355 <li class="listitem">
2356 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
2357   <span class="keyword">void</span> <a name="idp32091024-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Insert the range <code class="computeroutput">[first, last)</code> before the specified position. <p>
2358
2359
2360
2361 </p>
2362 <p><b>Exception Safety.&#160;</b>Basic. </p>
2363 <p>
2364 </p>
2365 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2366 <p>
2367 </p>
2368 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">[size() + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity().capacity(), size() + std::distance(first, last)]</code> if the <code class="computeroutput">InputIterator</code> is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html" target="_top">RandomAccessIterator</a>). </p>
2369 <p>
2370 </p>
2371 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
2372 <br>
2373  <code class="computeroutput">|1|2|3|4| | |</code><br>
2374  <code class="computeroutput">p ___^</code><br>
2375 <br>
2376 After inserting a range of elements before the position <code class="computeroutput">p</code>:<br>
2377 <br>
2378  <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br>
2379 <code class="computeroutput">insert(p, array, array + 5);</code><br>
2380 <br>
2381  actually only elements <code class="computeroutput">5</code>, <code class="computeroutput">6</code>, <code class="computeroutput">7</code> and <code class="computeroutput">8</code> from the specified range get inserted and elements <code class="computeroutput">3</code> and <code class="computeroutput">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>
2382 <br>
2383 <code class="computeroutput">|1|2|5|6|7|8|</code><br>
2384 <br>
2385 For comparison if the capacity would not be preserved the internal buffer would then result in <code class="computeroutput">|1|2|5|6|7|8|9|3|4|</code>. </p>
2386 <p>
2387 </p>
2388 <p><span class="bold"><strong>See Also:</strong></span></p>
2389 <p><code class="computeroutput">rinsert(iterator, value_type)</code>, <code class="computeroutput">rinsert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, value_type)</code>, <code class="computeroutput">insert(iterator, size_type, value_type)</code>, <code class="computeroutput">insert(iterator, InputIterator, InputIterator)</code> </p>
2390 <p>
2391 </p>
2392 <div class="variablelist"><table border="0" class="variablelist compact">
2393 <colgroup>
2394 <col align="left" valign="top">
2395 <col>
2396 </colgroup>
2397 <tbody>
2398 <tr>
2399 <td><p><span class="term">Parameters:</span></p></td>
2400 <td><div class="variablelist"><table border="0" class="variablelist compact">
2401 <colgroup>
2402 <col align="left" valign="top">
2403 <col>
2404 </colgroup>
2405 <tbody>
2406 <tr>
2407 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2408 <td><p>The beginning of the range to be inserted. </p></td>
2409 </tr>
2410 <tr>
2411 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2412 <td><p>The end of the range to be inserted. </p></td>
2413 </tr>
2414 <tr>
2415 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2416 <td><p>An iterator specifying the position where the range will be inserted. </p></td>
2417 </tr>
2418 </tbody>
2419 </table></div></td>
2420 </tr>
2421 <tr>
2422 <td><p><span class="term">Requires:</span></p></td>
2423 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> or its end.<br>
2424  Valid range <code class="computeroutput">[first, last)</code> where <code class="computeroutput">first</code> and <code class="computeroutput">last</code> meet the requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">InputIterator</a>. </p></td>
2425 </tr>
2426 <tr>
2427 <td><p><span class="term">Postconditions:</span></p></td>
2428 <td><p>Elements from the range <code class="computeroutput">[first, last - max[0, distance(first, last) - (end() - pos) - reserve()])</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
2429 The number of <code class="computeroutput">min[end() - pos, max[0, distance(first, last) - reserve()]]</code> elements will be overwritten at the end of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br>
2430 (See <span class="emphasis"><em>Example</em></span> for the explanation.)<br>
2431 <br>
2432  The amount of allocated memory in the internal buffer may be predictively increased. </p></td>
2433 </tr>
2434 <tr>
2435 <td><p><span class="term">Throws:</span></p></td>
2436 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
2437 </tr>
2438 </tbody>
2439 </table></div>
2440 </li>
2441 <li class="listitem">
2442 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32128528-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Remove an element at the specified position. <p>
2443
2444
2445
2446
2447 </p>
2448 <p><b>Exception Safety.&#160;</b>Basic. </p>
2449 <p>
2450 </p>
2451 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2452 <p>
2453 </p>
2454 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2455 <p>
2456 </p>
2457 <p><span class="bold"><strong>See Also:</strong></span></p>
2458 <p><code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p>
2459 <p>
2460 </p>
2461 <div class="variablelist"><table border="0" class="variablelist compact">
2462 <colgroup>
2463 <col align="left" valign="top">
2464 <col>
2465 </colgroup>
2466 <tbody>
2467 <tr>
2468 <td><p><span class="term">Parameters:</span></p></td>
2469 <td><div class="variablelist"><table border="0" class="variablelist compact">
2470 <colgroup>
2471 <col align="left" valign="top">
2472 <col>
2473 </colgroup>
2474 <tbody><tr>
2475 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2476 <td><p>An iterator pointing at the element to be removed. </p></td>
2477 </tr></tbody>
2478 </table></div></td>
2479 </tr>
2480 <tr>
2481 <td><p><span class="term">Requires:</span></p></td>
2482 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> (but not an <code class="computeroutput">end()</code>). </p></td>
2483 </tr>
2484 <tr>
2485 <td><p><span class="term">Postconditions:</span></p></td>
2486 <td><p>The element at the position <code class="computeroutput">pos</code> is removed.<br>
2487 <br>
2488  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
2489 </tr>
2490 <tr>
2491 <td><p><span class="term">Returns:</span></p></td>
2492 <td><p>Iterator to the first element remaining beyond the removed element or <code class="computeroutput">end()</code> if no such element exists. </p></td>
2493 </tr>
2494 <tr>
2495 <td><p><span class="term">Throws:</span></p></td>
2496 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws or nothing if <code class="computeroutput">T::operator = (T&amp;&amp;)</code> is noexcept. </td>
2497 </tr>
2498 </tbody>
2499 </table></div>
2500 </li>
2501 <li class="listitem">
2502 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32145520-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> first<span class="special">,</span> <span class="identifier">iterator</span> last<span class="special">)</span><span class="special">;</span></pre>Erase the range <code class="computeroutput">[first, last)</code>. <p>
2503
2504
2505
2506
2507 </p>
2508 <p><b>Exception Safety.&#160;</b>Basic. </p>
2509 <p>
2510 </p>
2511 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2512 <p>
2513 </p>
2514 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2515 <p>
2516 </p>
2517 <p><span class="bold"><strong>See Also:</strong></span></p>
2518 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p>
2519 <p>
2520 </p>
2521 <div class="variablelist"><table border="0" class="variablelist compact">
2522 <colgroup>
2523 <col align="left" valign="top">
2524 <col>
2525 </colgroup>
2526 <tbody>
2527 <tr>
2528 <td><p><span class="term">Parameters:</span></p></td>
2529 <td><div class="variablelist"><table border="0" class="variablelist compact">
2530 <colgroup>
2531 <col align="left" valign="top">
2532 <col>
2533 </colgroup>
2534 <tbody>
2535 <tr>
2536 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2537 <td><p>The beginning of the range to be removed. </p></td>
2538 </tr>
2539 <tr>
2540 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2541 <td><p>The end of the range to be removed. </p></td>
2542 </tr>
2543 </tbody>
2544 </table></div></td>
2545 </tr>
2546 <tr>
2547 <td><p><span class="term">Requires:</span></p></td>
2548 <td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td>
2549 </tr>
2550 <tr>
2551 <td><p><span class="term">Postconditions:</span></p></td>
2552 <td><p>The elements from the range <code class="computeroutput">[first, last)</code> are removed. (If <code class="computeroutput">first == last</code> nothing is removed.)<br>
2553 <br>
2554  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
2555 </tr>
2556 <tr>
2557 <td><p><span class="term">Returns:</span></p></td>
2558 <td><p>Iterator to the first element remaining beyond the removed elements or <code class="computeroutput">end()</code> if no such element exists. </p></td>
2559 </tr>
2560 <tr>
2561 <td><p><span class="term">Throws:</span></p></td>
2562 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws or nothing if <code class="computeroutput">T::operator = (T&amp;&amp;)</code> is noexcept. </td>
2563 </tr>
2564 </tbody>
2565 </table></div>
2566 </li>
2567 <li class="listitem">
2568 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32163296-bb"></a><span class="identifier">rerase</span><span class="special">(</span><span class="identifier">iterator</span> pos<span class="special">)</span><span class="special">;</span></pre>Remove an element at the specified position. <p>
2569
2570
2571
2572
2573 </p>
2574 <p><b>Exception Safety.&#160;</b>Basic. </p>
2575 <p>
2576 </p>
2577 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2578 <p>
2579 </p>
2580 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2581 <p>
2582 </p>
2583 <div class="note"><table border="0" summary="Note">
2584 <tr>
2585 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
2586 <th align="left">Note</th>
2587 </tr>
2588 <tr><td align="left" valign="top"><p>Basically there is no difference between <code class="computeroutput">erase(iterator)</code> and this method. It is implemented only for consistency with the base <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p></td></tr>
2589 </table></div>
2590 <p>
2591 </p>
2592 <p><span class="bold"><strong>See Also:</strong></span></p>
2593 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">clear()</code> </p>
2594 <p>
2595 </p>
2596 <div class="variablelist"><table border="0" class="variablelist compact">
2597 <colgroup>
2598 <col align="left" valign="top">
2599 <col>
2600 </colgroup>
2601 <tbody>
2602 <tr>
2603 <td><p><span class="term">Parameters:</span></p></td>
2604 <td><div class="variablelist"><table border="0" class="variablelist compact">
2605 <colgroup>
2606 <col align="left" valign="top">
2607 <col>
2608 </colgroup>
2609 <tbody><tr>
2610 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2611 <td><p>An iterator pointing at the element to be removed. </p></td>
2612 </tr></tbody>
2613 </table></div></td>
2614 </tr>
2615 <tr>
2616 <td><p><span class="term">Requires:</span></p></td>
2617 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code> (but not an <code class="computeroutput">end()</code>).<br>
2618 <br>
2619  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
2620 </tr>
2621 <tr>
2622 <td><p><span class="term">Postconditions:</span></p></td>
2623 <td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td>
2624 </tr>
2625 <tr>
2626 <td><p><span class="term">Returns:</span></p></td>
2627 <td><p>Iterator to the first element remaining in front of the removed element or <code class="computeroutput">begin()</code> if no such element exists. </p></td>
2628 </tr>
2629 <tr>
2630 <td><p><span class="term">Throws:</span></p></td>
2631 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws or nothing if <code class="computeroutput">T::operator = (T&amp;&amp;)</code> is noexcept. </td>
2632 </tr>
2633 </tbody>
2634 </table></div>
2635 </li>
2636 <li class="listitem">
2637 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idp32182256-bb"></a><span class="identifier">rerase</span><span class="special">(</span><span class="identifier">iterator</span> first<span class="special">,</span> <span class="identifier">iterator</span> last<span class="special">)</span><span class="special">;</span></pre>Erase the range <code class="computeroutput">[first, last)</code>. <p>
2638
2639
2640
2641
2642 </p>
2643 <p><b>Exception Safety.&#160;</b>Basic. </p>
2644 <p>
2645 </p>
2646 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2647 <p>
2648 </p>
2649 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2650 <p>
2651 </p>
2652 <div class="note"><table border="0" summary="Note">
2653 <tr>
2654 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
2655 <th align="left">Note</th>
2656 </tr>
2657 <tr><td align="left" valign="top"><p>Basically there is no difference between <code class="computeroutput">erase(iterator, iterator)</code> and this method. It is implemented only for consistency with the base <code class="computeroutput">&lt;<code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p></td></tr>
2658 </table></div>
2659 <p>
2660 </p>
2661 <p><span class="bold"><strong>See Also:</strong></span></p>
2662 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">clear()</code> </p>
2663 <p>
2664 </p>
2665 <div class="variablelist"><table border="0" class="variablelist compact">
2666 <colgroup>
2667 <col align="left" valign="top">
2668 <col>
2669 </colgroup>
2670 <tbody>
2671 <tr>
2672 <td><p><span class="term">Parameters:</span></p></td>
2673 <td><div class="variablelist"><table border="0" class="variablelist compact">
2674 <colgroup>
2675 <col align="left" valign="top">
2676 <col>
2677 </colgroup>
2678 <tbody>
2679 <tr>
2680 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2681 <td><p>The beginning of the range to be removed. </p></td>
2682 </tr>
2683 <tr>
2684 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2685 <td><p>The end of the range to be removed. </p></td>
2686 </tr>
2687 </tbody>
2688 </table></div></td>
2689 </tr>
2690 <tr>
2691 <td><p><span class="term">Requires:</span></p></td>
2692 <td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td>
2693 </tr>
2694 <tr>
2695 <td><p><span class="term">Postconditions:</span></p></td>
2696 <td><p>The elements from the range <code class="computeroutput">[first, last)</code> are removed. (If <code class="computeroutput">first == last</code> nothing is removed.)<br>
2697 <br>
2698  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
2699 </tr>
2700 <tr>
2701 <td><p><span class="term">Returns:</span></p></td>
2702 <td><p>Iterator to the first element remaining in front of the removed elements or <code class="computeroutput">begin()</code> if no such element exists. </p></td>
2703 </tr>
2704 <tr>
2705 <td><p><span class="term">Throws:</span></p></td>
2706 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws or nothing if <code class="computeroutput">T::operator = (T&amp;&amp;)</code> is noexcept. </td>
2707 </tr>
2708 </tbody>
2709 </table></div>
2710 </li>
2711 <li class="listitem">
2712 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32202176-bb"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Remove all stored elements from the space optimized circular buffer. <p>
2713
2714 </p>
2715 <p><b>Exception Safety.&#160;</b>Basic. </p>
2716 <p>
2717 </p>
2718 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2719 <p>
2720 </p>
2721 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffe_idp31480224.html" title="Class template circular_buffer_space_optimized">circular_buffer_space_optimized</a></code></code>). </p>
2722 <p>
2723 </p>
2724 <p><span class="bold"><strong>See Also:</strong></span></p>
2725 <p><code class="computeroutput">~circular_buffer_space_optimized()</code>, <code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code> </p>
2726 <p>
2727 </p>
2728 <div class="variablelist"><table border="0" class="variablelist compact">
2729 <colgroup>
2730 <col align="left" valign="top">
2731 <col>
2732 </colgroup>
2733 <tbody>
2734 <tr>
2735 <td><p><span class="term">Postconditions:</span></p></td>
2736 <td><p><code class="computeroutput">size() == 0</code><br>
2737 <br>
2738  The amount of allocated memory in the internal buffer may be predictively decreased. </p></td>
2739 </tr>
2740 <tr>
2741 <td><p><span class="term">Throws:</span></p></td>
2742 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
2743 </tr>
2744 </tbody>
2745 </table></div>
2746 </li>
2747 </ol></div>
2748 </div>
2749 <div class="refsect2">
2750 <a name="idp148016208"></a><h3>
2751 <a name="idp32330288-bb"></a><code class="computeroutput">circular_buffer_space_optimized</code> private member functions</h3>
2752 <div class="orderedlist"><ol class="orderedlist" type="1">
2753 <li class="listitem">
2754 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32330864-bb"></a><span class="identifier">adjust_min_capacity</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Adjust the amount of allocated memory. </li>
2755 <li class="listitem">
2756 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idp32332016-bb"></a><span class="identifier">ensure_reserve</span><span class="special">(</span><span class="identifier">size_type</span> new_capacity<span class="special">,</span> <span class="identifier">size_type</span> buffer_size<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Ensure the reserve for possible growth up. </li>
2757 <li class="listitem">
2758 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32334832-bb"></a><span class="identifier">check_low_capacity</span><span class="special">(</span><span class="identifier">size_type</span> n <span class="special">=</span> <span class="number">1</span><span class="special">)</span><span class="special">;</span></pre>Check for low capacity. </li>
2759 <li class="listitem">
2760 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32336960-bb"></a><span class="identifier">check_high_capacity</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Check for high capacity. </li>
2761 <li class="listitem">
2762 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32338112-bb"></a><span class="identifier">reduce_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for reducing the capacity. </li>
2763 <li class="listitem">
2764 <pre class="literallayout"><span class="keyword">void</span> <a name="idp32339968-bb"></a><span class="identifier">reduce_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for reducing the capacity. </li>
2765 <li class="listitem">
2766 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
2767   <span class="keyword">void</span> <a name="idp32341824-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span> pos<span class="special">,</span> <span class="identifier">IntegralType</span> n<span class="special">,</span> <span class="identifier">IntegralType</span> item<span class="special">,</span>
2768               <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized insert method. </li>
2769 <li class="listitem">
2770 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
2771   <span class="keyword">void</span> <a name="idp32346576-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span> pos<span class="special">,</span> <span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span>
2772               <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized insert method. </li>
2773 <li class="listitem">
2774 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
2775   <span class="keyword">void</span> <a name="idp32351328-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span> pos<span class="special">,</span> <span class="identifier">IntegralType</span> n<span class="special">,</span> <span class="identifier">IntegralType</span> item<span class="special">,</span>
2776                <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized rinsert method. </li>
2777 <li class="listitem">
2778 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
2779   <span class="keyword">void</span> <a name="idp32356080-bb"></a><span class="identifier">rinsert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">iterator</span> <span class="special">&amp;</span> pos<span class="special">,</span> <span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span>
2780                <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized rinsert method. </li>
2781 </ol></div>
2782 </div>
2783 <div class="refsect2">
2784 <a name="idp148111840"></a><h3>
2785 <a name="idp32360992-bb"></a><code class="computeroutput">circular_buffer_space_optimized</code> private static functions</h3>
2786 <div class="orderedlist"><ol class="orderedlist" type="1">
2787 <li class="listitem">
2788 <pre class="literallayout"><span class="keyword">static</span> <span class="identifier">size_type</span>
2789 <a name="idp32361568-bb"></a><span class="identifier">init_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">)</span><span class="special">;</span></pre>Determine the initial capacity. </li>
2790 <li class="listitem">
2791 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> IntegralType<span class="special">&gt;</span>
2792   <span class="keyword">static</span> <span class="identifier">size_type</span>
2793   <a name="idp32364368-bb"></a><span class="identifier">init_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">,</span> <span class="identifier">IntegralType</span> n<span class="special">,</span>
2794                 <span class="identifier">IntegralType</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">true_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for determining the initial capacity. </li>
2795 <li class="listitem">
2796 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
2797   <span class="keyword">static</span> <span class="identifier">size_type</span>
2798   <a name="idp32369424-bb"></a><span class="identifier">init_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">,</span> <span class="identifier">Iterator</span> first<span class="special">,</span>
2799                 <span class="identifier">Iterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">false_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for determining the initial capacity. </li>
2800 <li class="listitem">
2801 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
2802   <span class="keyword">static</span> <span class="identifier">size_type</span>
2803   <a name="idp32374480-bb"></a><span class="identifier">init_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
2804                 <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">input_iterator_tag</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for determining the initial capacity. </li>
2805 <li class="listitem">
2806 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIterator<span class="special">&gt;</span>
2807   <span class="keyword">static</span> <span class="identifier">size_type</span>
2808   <a name="idp32379552-bb"></a><span class="identifier">init_capacity</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">capacity_type</span> <span class="special">&amp;</span> capacity_ctrl<span class="special">,</span> <span class="identifier">ForwardIterator</span> first<span class="special">,</span>
2809                 <span class="identifier">ForwardIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span></pre>Specialized method for determining the initial capacity. </li>
2810 </ol></div>
2811 </div>
2812 </div>
2813 </div>
2814 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
2815 <td align="left"></td>
2816 <td align="right"><div class="copyright-footer">Copyright &#169; 2003-2013 Jan Gaspar<p>
2817         Distributed under the Boost Software License, Version 1.0. (See accompanying
2818         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
2819       </p>
2820 </div></td>
2821 </tr></table>
2822 <hr>
2823 <div class="spirit-nav">
2824 <a accesskey="p" href="swap_idp31458912.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_circular_buffer_c___reference.html#header.boost.circular_buffer.space_optimized_hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../circular_buffer/s14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
2825 </div>
2826 </body>
2827 </html>