doc/html/boost/circular_idm46495624036048.html

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