doc/html/boost/circular_buffer.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</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.base_hpp" title="Header &lt;boost/circular_buffer/base.hpp&gt;">
  10 <link rel="prev" href="../BOOST_CB_ENABLE_DEBUG.html" title="Macro BOOST_CB_ENABLE_DEBUG">
  11 <link rel="next" href="operator_idm46495624142096.html" title="Function template operator==">
  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="../BOOST_CB_ENABLE_DEBUG.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.base_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="operator_idm46495624142096.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
  25 </div>
  26 <div class="refentry">
  27 <a name="boost.circular_buffer"></a><div class="titlepage"></div>
  28 <div class="refnamediv">
  29 <h2><span class="refentrytitle">Class template circular_buffer</span></h2>
  30 <p>boost::circular_buffer &#8212; Circular buffer - a STL compliant container. </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.base_hpp" title="Header &lt;boost/circular_buffer/base.hpp&gt;">boost/circular_buffer/base.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_buffer.html" title="Class template circular_buffer">circular_buffer</a> <span class="special">:</span> <span class="keyword">private</span> <span class="identifier">empty_value</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">{</span>
  37 <span class="keyword">public</span><span class="special">:</span>
  38   <span class="comment">// <a class="link" href="circular_buffer.html#boost.circular_buffertypes">types</a></span>
  39   <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>                                                                                               <a name="boost.circular_buffer.this_type"></a><span class="identifier">this_type</span><span class="special">;</span>               <span class="comment">// The type of this <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  40   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</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_buffer.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>              <span class="comment">// The type of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  41   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">pointer</span>                                                                            <a name="boost.circular_buffer.pointer"></a><span class="identifier">pointer</span><span class="special">;</span>                 <span class="comment">// A pointer to an element. </span>
  42   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</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_buffer.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>           <span class="comment">// A const pointer to the element. </span>
  43   <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&amp;</span>                                                                                                              <a name="boost.circular_buffer.reference"></a><span class="identifier">reference</span><span class="special">;</span>               <span class="comment">// A reference to an element. </span>
  44   <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span>                                                                                                        <a name="boost.circular_buffer.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>         <span class="comment">// A const reference to an element. </span>
  45   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">difference_type</span>                                                                    <a class="link" href="circular_buffer.html#boost.circular_buffer.difference_type"><span class="identifier">difference_type</span></a><span class="special">;</span>
  46   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">size_type</span>                                                                          <a class="link" href="circular_buffer.html#boost.circular_buffer.size_type"><span class="identifier">size_type</span></a><span class="special">;</span>
  47   <span class="keyword">typedef</span> <span class="identifier">Alloc</span>                                                                                                                     <a name="boost.circular_buffer.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span>          <span class="comment">// The type of an allocator used in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  48   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">iterator</span><span class="special">&lt;</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">cb_details</span><span class="special">::</span><span class="identifier">const_traits</span><span class="special">&lt;</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>    <a name="boost.circular_buffer.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span>          <span class="comment">// A const (random access) iterator used to iterate through the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  49   <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">iterator</span><span class="special">&lt;</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">cb_details</span><span class="special">::</span><span class="identifier">nonconst_traits</span><span class="special">&lt;</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span> <span class="identifier">Alloc</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <a name="boost.circular_buffer.iterator"></a><span class="identifier">iterator</span><span class="special">;</span>                <span class="comment">// A (random access) iterator used to iterate through the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  50   <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span>                                                                                   <a name="boost.circular_buffer.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>  <span class="comment">// A const iterator used to iterate backwards through a <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  51   <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special">&lt;</span> <span class="identifier">iterator</span> <span class="special">&gt;</span>                                                                                         <a name="boost.circular_buffer.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>        <span class="comment">// An iterator used to iterate backwards through a <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </span>
  52   <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">&gt;</span>                                                                                           <a class="link" href="circular_buffer.html#boost.circular_buffer.array_range"><span class="identifier">array_range</span></a><span class="special">;</span>
  53   <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">&gt;</span>                                                                                     <a class="link" href="circular_buffer.html#boost.circular_buffer.const_array_range"><span class="identifier">const_array_range</span></a><span class="special">;</span>
  54   <span class="keyword">typedef</span> <span class="identifier">size_type</span>                                                                                                                 <a class="link" href="circular_buffer.html#boost.circular_buffer.capacity_type"><span class="identifier">capacity_type</span></a><span class="special">;</span>
  55   <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span>                                                                                                        <a name="boost.circular_buffer.param_value_type"></a><span class="identifier">param_value_type</span><span class="special">;</span>        <span class="comment">// A type representing the "best" way to pass the value_type to a method. </span>
  56   <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&amp;&amp;</span>                                                                                                             <a class="link" href="circular_buffer.html#boost.circular_buffer.rvalue_type"><span class="identifier">rvalue_type</span></a><span class="special">;</span>
  57
  58   <span class="comment">// <a class="link" href="circular_buffer.html#boost.circular_bufferconstruct-copy-destruct">construct/copy/destruct</a></span>
  59   <span class="keyword">explicit</span> <a class="link" href="circular_buffer.html#idm46495624272368-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  60   <span class="keyword">explicit</span> <a class="link" href="circular_buffer.html#idm46495624259808-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span>
  61                            <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  62   <a class="link" href="circular_buffer.html#idm46495624251184-bb"><span class="identifier">circular_buffer</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>
  63                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  64   <a class="link" href="circular_buffer.html#idm46495624239024-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">,</span> <span class="identifier">param_value_type</span><span class="special">,</span>
  65                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  66   <a class="link" href="circular_buffer.html#idm46495624224000-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="keyword">const</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">&amp;</span><span class="special">)</span><span class="special">;</span>
  67   <a class="link" href="circular_buffer.html#idm46495624215760-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</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">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  68   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  69     <a class="link" href="circular_buffer.html#idm46495624207616-bb"><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  70                     <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">allocator_type</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  71   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  72     <a class="link" href="circular_buffer.html#idm46495624194128-bb"><span class="identifier">circular_buffer</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>
  73                     <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>
  74   <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">&amp;</span> <a class="link" href="circular_buffer.html#idm46495624166672-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_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">&amp;</span><span class="special">)</span><span class="special">;</span>
  75   <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">&amp;</span>
  76   <a class="link" href="circular_buffer.html#idm46495624150592-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</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">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  77   <a class="link" href="circular_buffer.html#idm46495624175088-bb"><span class="special">~</span><span class="identifier">circular_buffer</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  78
  79   <span class="comment">// <a class="link" href="circular_buffer.html#idm46495625372432-bb">public member functions</a></span>
  80   <span class="identifier">allocator_type</span> <a class="link" href="circular_buffer.html#idm46495625371872-bb"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  81   <span class="identifier">allocator_type</span> <span class="special">&amp;</span> <a class="link" href="circular_buffer.html#idm46495625363216-bb"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  82   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495625353680-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  83   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495625341024-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  84   <span class="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm46495625328192-bb"><span class="identifier">begin</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="identifier">const_iterator</span> <a class="link" href="circular_buffer.html#idm46495625315520-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  86   <span class="identifier">reverse_iterator</span> <a class="link" href="circular_buffer.html#idm46495625302672-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  87   <span class="identifier">reverse_iterator</span> <a class="link" href="circular_buffer.html#idm46495625290000-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  88   <span class="identifier">const_reverse_iterator</span> <a class="link" href="circular_buffer.html#idm46495625277152-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  89   <span class="identifier">const_reverse_iterator</span> <a class="link" href="circular_buffer.html#idm46495625264464-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  90   <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm46495625251760-bb"><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
  91   <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm46495625240480-bb"><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  92   <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm46495625228912-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
  93   <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm46495625217600-bb"><span class="identifier">at</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  94   <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm46495625206000-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  95   <span class="identifier">reference</span> <a class="link" href="circular_buffer.html#idm46495625195888-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  96   <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm46495625185792-bb"><span class="identifier">front</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  97   <span class="identifier">const_reference</span> <a class="link" href="circular_buffer.html#idm46495625175408-bb"><span class="identifier">back</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  98   <span class="identifier">array_range</span> <a class="link" href="circular_buffer.html#idm46495625165024-bb"><span class="identifier">array_one</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  99   <span class="identifier">array_range</span> <a class="link" href="circular_buffer.html#idm46495625131696-bb"><span class="identifier">array_two</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 100   <span class="identifier">const_array_range</span> <a class="link" href="circular_buffer.html#idm46495625121312-bb"><span class="identifier">array_one</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 101   <span class="identifier">const_array_range</span> <a class="link" href="circular_buffer.html#idm46495625110224-bb"><span class="identifier">array_two</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 102   <span class="identifier">pointer</span> <a class="link" href="circular_buffer.html#idm46495625099568-bb"><span class="identifier">linearize</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 103   <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm46495625083664-bb"><span class="identifier">is_linearized</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 104   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495625071152-bb"><span class="identifier">rotate</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
 105   <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm46495625044976-bb"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 106   <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm46495625033232-bb"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 107   <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm46495625021920-bb"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 108   <span class="keyword">bool</span> <a class="link" href="circular_buffer.html#idm46495625010816-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>
 109   <span class="identifier">size_type</span> <a class="link" href="circular_buffer.html#idm46495624998848-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>
 110   <span class="identifier">capacity_type</span> <a class="link" href="circular_buffer.html#idm46495624988096-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>
 111   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624976336-bb"><span class="identifier">set_capacity</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">)</span><span class="special">;</span>
 112   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624957840-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>
 113   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624935600-bb"><span class="identifier">rset_capacity</span></a><span class="special">(</span><span class="identifier">capacity_type</span><span class="special">)</span><span class="special">;</span>
 114   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624917104-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>
 115   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624894864-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>
 116   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624875856-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>
 117   <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_buffer.html#idm46495624853968-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>
 118   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 119     <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624833984-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>
 120   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624808464-bb"><span class="identifier">swap</span></a><span class="special">(</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">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 121   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624793200-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>
 122   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624778080-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>
 123   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624762928-bb"><span class="identifier">push_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 124   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624748464-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>
 125   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624733328-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>
 126   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624718160-bb"><span class="identifier">push_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 127   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624703696-bb"><span class="identifier">pop_back</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 128   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624691776-bb"><span class="identifier">pop_front</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 129   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624679856-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>
 130   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624655488-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>
 131   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624631136-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 132   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624607440-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>
 133   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 134     <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624575088-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>
 135   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624534720-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>
 136   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624510848-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>
 137   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624486992-bb"><span class="identifier">rinsert</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 138   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624463808-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>
 139   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 140     <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624431968-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>
 141   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624392048-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 142   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624375712-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>
 143   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624358560-bb"><span class="identifier">rerase</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span><span class="special">;</span>
 144   <span class="identifier">iterator</span> <a class="link" href="circular_buffer.html#idm46495624339248-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>
 145   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624319920-bb"><span class="identifier">erase_begin</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 146   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624303152-bb"><span class="identifier">erase_end</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 147   <span class="keyword">void</span> <a class="link" href="circular_buffer.html#idm46495624286400-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 148 <span class="special">}</span><span class="special">;</span></pre></div>
 149 <div class="refsect1">
 150 <a name="id-1.3.9.16.3.3.4"></a><h2>Description</h2>
 151 <p>
 152 </p>
 153 <p><b>Type Requirements T.&#160;</b>The <code class="computeroutput">T</code> has to be <a href="https://www.boost.org/sgi/stl/Assignable.html" target="_top">SGIAssignable</a> (SGI STL defined combination of <a href="../../../../utility/Assignable.html" target="_top">Assignable</a> and <a href="../../../../utility/CopyConstructible.html" target="_top">CopyConstructible</a>). Moreover <code class="computeroutput">T</code> has to be <a href="https://www.boost.org/sgi/stl/DefaultConstructible.html" target="_top">DefaultConstructible</a> if supplied as a default parameter when invoking some of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>'s methods e.g. <code class="computeroutput">insert(iterator pos, const value_type&amp; item = value_type())</code>. And <a href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and/or <a href="../../../../utility/LessThanComparable.html" target="_top">LessThanComparable</a> if the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be compared with another container. </p>
 154 <p>
 155
 156 </p>
 157 <p><b>Type Requirements Alloc.&#160;</b>The <code class="computeroutput">Alloc</code> has to meet the allocator requirements imposed by STL. </p>
 158 <p>
 159 </p>
 160 <p><b>Default Alloc.&#160;</b>std::allocator&lt;T&gt;</p>
 161 <p>
 162 For detailed documentation of the <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a> visit: <a href="http://www.boost.org/libs/circular_buffer/doc/circular_buffer.html" target="_top">http://www.boost.org/libs/circular_buffer/doc/circular_buffer.html</a> </p>
 163 <div class="refsect2">
 164 <a name="id-1.3.9.16.3.3.4.3"></a><h3>Template Parameters</h3>
 165 <div class="orderedlist"><ol class="orderedlist" type="1">
 166 <li class="listitem">
 167 <pre class="literallayout"><span class="keyword">typename</span> T</pre>
 168 <p>The type of the elements stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. </p>
 169 </li>
 170 <li class="listitem">
 171 <pre class="literallayout"><span class="keyword">typename</span> Alloc</pre>
 172 <p>The allocator type used for all internal memory management. </p>
 173 </li>
 174 </ol></div>
 175 </div>
 176 <div class="refsect2">
 177 <a name="id-1.3.9.16.3.3.4.4"></a><h3>
 178 <a name="boost.circular_buffertypes"></a><code class="computeroutput">circular_buffer</code>
 179         public
 180        types</h3>
 181 <div class="orderedlist"><ol class="orderedlist" type="1">
 182 <li class="listitem">
 183 <p>
 184 <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</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_buffer.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span></p>
 185 <p>(A signed integral type used to represent the distance between two iterators.) </p>
 186 </li>
 187 <li class="listitem">
 188 <p>
 189 <span class="keyword">typedef</span> <span class="identifier">cb_details</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</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_buffer.size_type"></a><span class="identifier">size_type</span><span class="special">;</span></p>
 190 <p>(An unsigned integral type that can represent any non-negative value of the container's distance type.) </p>
 191 </li>
 192 <li class="listitem">
 193 <p>
 194 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">&gt;</span> <a name="boost.circular_buffer.array_range"></a><span class="identifier">array_range</span><span class="special">;</span></p>
 195 <p>(A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html" target="_top"><code class="computeroutput">std::pair</code></a> where its first element is a pointer to a beginning of an array and its second element represents a size of the array.) </p>
 196 </li>
 197 <li class="listitem">
 198 <p>
 199 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_pointer</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="special">&gt;</span> <a name="boost.circular_buffer.const_array_range"></a><span class="identifier">const_array_range</span><span class="special">;</span></p>
 200 <p>(A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html" target="_top"><code class="computeroutput">std::pair</code></a> where its first element is a pointer to a beginning of a const array and its second element represents a size of the const array.) </p>
 201 </li>
 202 <li class="listitem">
 203 <p>
 204 <span class="keyword">typedef</span> <span class="identifier">size_type</span> <a name="boost.circular_buffer.capacity_type"></a><span class="identifier">capacity_type</span><span class="special">;</span></p>
 205 <p>(Same as <code class="computeroutput">size_type</code> - defined for consistency with the __cbso class. </p>
 206 </li>
 207 <li class="listitem">
 208 <p>
 209 <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="special">&amp;&amp;</span> <a name="boost.circular_buffer.rvalue_type"></a><span class="identifier">rvalue_type</span><span class="special">;</span></p>
 210 <p>A type representing rvalue from param type. On compilers without rvalue references support this type is the Boost.Moves type used for emulation. </p>
 211 </li>
 212 </ol></div>
 213 </div>
 214 <div class="refsect2">
 215 <a name="id-1.3.9.16.3.3.4.5"></a><h3>
 216 <a name="boost.circular_bufferconstruct-copy-destruct"></a><code class="computeroutput">circular_buffer</code>
 217         public
 218        construct/copy/destruct</h3>
 219 <div class="orderedlist"><ol class="orderedlist" type="1">
 220 <li class="listitem">
 221 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm46495624272368-bb"></a><span class="identifier">circular_buffer</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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with zero capacity. <p>
 222
 223
 224 </p>
 225 <p><b>Complexity.&#160;</b>Constant. </p>
 226 <p>
 227 </p>
 228 <div class="warning"><table border="0" summary="Warning">
 229 <tr>
 230 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
 231 <th align="left">Warning</th>
 232 </tr>
 233 <tr><td align="left" valign="top"><p>Since Boost version 1.36 the behaviour of this constructor has changed. Now the constructor does not allocate any memory and both capacity and size are set to zero. Also note when inserting an element into a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with zero capacity (e.g. by <code class="computeroutput">push_back(const_reference)</code> or <code class="computeroutput">insert(iterator, value_type)</code>) nothing will be inserted and the size (as well as capacity) remains zero. </p></td></tr>
 234 </table></div>
 235 <p>
 236 </p>
 237 <div class="note"><table border="0" summary="Note">
 238 <tr>
 239 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
 240 <th align="left">Note</th>
 241 </tr>
 242 <tr><td align="left" valign="top"><p>You can explicitly set the capacity by calling the <code class="computeroutput">set_capacity(capacity_type)</code> method or you can use the other constructor with the capacity specified. </p></td></tr>
 243 </table></div>
 244 <p>
 245 </p>
 246 <p><span class="bold"><strong>See Also:</strong></span></p>
 247 <p><code class="computeroutput">circular_buffer(capacity_type, const allocator_type&amp; alloc)</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p>
 248 <p>
 249 </p>
 250 <p>
 251 </p>
 252 <div class="variablelist"><table border="0" class="variablelist compact">
 253 <colgroup>
 254 <col align="left" valign="top">
 255 <col>
 256 </colgroup>
 257 <tbody>
 258 <tr>
 259 <td><p><span class="term">Parameters:</span></p></td>
 260 <td><div class="variablelist"><table border="0" class="variablelist compact">
 261 <colgroup>
 262 <col align="left" valign="top">
 263 <col>
 264 </colgroup>
 265 <tbody><tr>
 266 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 267 <td><p>The allocator. </p></td>
 268 </tr></tbody>
 269 </table></div></td>
 270 </tr>
 271 <tr>
 272 <td><p><span class="term">Postconditions:</span></p></td>
 273 <td><p><code class="computeroutput">capacity() == 0 &amp;&amp; size() == 0</code> </p></td>
 274 </tr>
 275 <tr>
 276 <td><p><span class="term">Throws:</span></p></td>
 277 <td>Nothing. </td>
 278 </tr>
 279 </tbody>
 280 </table></div>
 281 </li>
 282 <li class="listitem">
 283 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm46495624259808-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span>
 284                          <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity. <p>
 285
 286
 287 </p>
 288 <p><b>Complexity.&#160;</b>Constant. </p>
 289 <p>
 290 </p>
 291 <div class="variablelist"><table border="0" class="variablelist compact">
 292 <colgroup>
 293 <col align="left" valign="top">
 294 <col>
 295 </colgroup>
 296 <tbody>
 297 <tr>
 298 <td><p><span class="term">Parameters:</span></p></td>
 299 <td><div class="variablelist"><table border="0" class="variablelist compact">
 300 <colgroup>
 301 <col align="left" valign="top">
 302 <col>
 303 </colgroup>
 304 <tbody>
 305 <tr>
 306 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 307 <td><p>The allocator. </p></td>
 308 </tr>
 309 <tr>
 310 <td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td>
 311 <td><p>The maximum number of elements which can be stored in the <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>
 312 </tr>
 313 </tbody>
 314 </table></div></td>
 315 </tr>
 316 <tr>
 317 <td><p><span class="term">Postconditions:</span></p></td>
 318 <td><p><code class="computeroutput">capacity() == buffer_capacity &amp;&amp; size() == 0</code> </p></td>
 319 </tr>
 320 <tr>
 321 <td><p><span class="term">Throws:</span></p></td>
 322 <td>An allocation error if memory is exhausted (<code class="computeroutput">std::bad_alloc</code> if the standard allocator is used). </td>
 323 </tr>
 324 </tbody>
 325 </table></div>
 326 </li>
 327 <li class="listitem">
 328 <pre class="literallayout"><a name="idm46495624251184-bb"></a><span class="identifier">circular_buffer</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>
 329                 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p>
 330
 331
 332 </p>
 333 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
 334 <p>
 335 </p>
 336 <div class="variablelist"><table border="0" class="variablelist compact">
 337 <colgroup>
 338 <col align="left" valign="top">
 339 <col>
 340 </colgroup>
 341 <tbody>
 342 <tr>
 343 <td><p><span class="term">Parameters:</span></p></td>
 344 <td><div class="variablelist"><table border="0" class="variablelist compact">
 345 <colgroup>
 346 <col align="left" valign="top">
 347 <col>
 348 </colgroup>
 349 <tbody>
 350 <tr>
 351 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 352 <td><p>The allocator. </p></td>
 353 </tr>
 354 <tr>
 355 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
 356 <td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
 357 </tr>
 358 <tr>
 359 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
 360 <td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
 361 </tr>
 362 </tbody>
 363 </table></div></td>
 364 </tr>
 365 <tr>
 366 <td><p><span class="term">Postconditions:</span></p></td>
 367 <td><p><code class="computeroutput">capacity() == n &amp;&amp; full() &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this)[n - 1] == item </code> </p></td>
 368 </tr>
 369 <tr>
 370 <td><p><span class="term">Throws:</span></p></td>
 371 <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>
 372 </tr>
 373 </tbody>
 374 </table></div>
 375 </li>
 376 <li class="listitem">
 377 <pre class="literallayout"><a name="idm46495624239024-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">size_type</span> n<span class="special">,</span>
 378                 <span class="identifier">param_value_type</span> item<span class="special">,</span>
 379                 <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with <code class="computeroutput">n</code> copies of <code class="computeroutput">item</code>. <p>
 380
 381
 382
 383 </p>
 384 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
 385 <p>
 386 </p>
 387 <div class="variablelist"><table border="0" class="variablelist compact">
 388 <colgroup>
 389 <col align="left" valign="top">
 390 <col>
 391 </colgroup>
 392 <tbody>
 393 <tr>
 394 <td><p><span class="term">Parameters:</span></p></td>
 395 <td><div class="variablelist"><table border="0" class="variablelist compact">
 396 <colgroup>
 397 <col align="left" valign="top">
 398 <col>
 399 </colgroup>
 400 <tbody>
 401 <tr>
 402 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 403 <td><p>The allocator. </p></td>
 404 </tr>
 405 <tr>
 406 <td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td>
 407 <td><p>The capacity of the created <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>
 408 </tr>
 409 <tr>
 410 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
 411 <td><p>The element the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
 412 </tr>
 413 <tr>
 414 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
 415 <td><p>The number of elements the created <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
 416 </tr>
 417 </tbody>
 418 </table></div></td>
 419 </tr>
 420 <tr>
 421 <td><p><span class="term">Requires:</span></p></td>
 422 <td><p><code class="computeroutput">buffer_capacity &gt;= n</code> </p></td>
 423 </tr>
 424 <tr>
 425 <td><p><span class="term">Postconditions:</span></p></td>
 426 <td><p><code class="computeroutput">capacity() == buffer_capacity &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this)[n - 1] == item</code> </p></td>
 427 </tr>
 428 <tr>
 429 <td><p><span class="term">Throws:</span></p></td>
 430 <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>
 431 </tr>
 432 </tbody>
 433 </table></div>
 434 </li>
 435 <li class="listitem">
 436 <pre class="literallayout"><a name="idm46495624224000-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="keyword">const</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">&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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>.
 437
 438
 439 </p>
 440 <p><b>Complexity.&#160;</b>Linear (in the size of <code class="computeroutput">cb</code>). </p>
 441 <p>
 442 </p>
 443 <div class="variablelist"><table border="0" class="variablelist compact">
 444 <colgroup>
 445 <col align="left" valign="top">
 446 <col>
 447 </colgroup>
 448 <tbody>
 449 <tr>
 450 <td><p><span class="term">Parameters:</span></p></td>
 451 <td><div class="variablelist"><table border="0" class="variablelist compact">
 452 <colgroup>
 453 <col align="left" valign="top">
 454 <col>
 455 </colgroup>
 456 <tbody><tr>
 457 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 458 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to be copied. </p></td>
 459 </tr></tbody>
 460 </table></div></td>
 461 </tr>
 462 <tr>
 463 <td><p><span class="term">Postconditions:</span></p></td>
 464 <td><p><code class="computeroutput">*this == cb</code> </p></td>
 465 </tr>
 466 <tr>
 467 <td><p><span class="term">Throws:</span></p></td>
 468 <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>
 469 </tr>
 470 </tbody>
 471 </table></div>
 472 </li>
 473 <li class="listitem">
 474 <pre class="literallayout"><a name="idm46495624215760-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</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">&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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> from <code class="computeroutput">cb</code>, leaving <code class="computeroutput">cb</code> empty.
 475
 476
 477
 478 </p>
 479 <p><b>Constant.&#160;</b></p>
 480 <p>
 481 </p>
 482 <div class="variablelist"><table border="0" class="variablelist compact">
 483 <colgroup>
 484 <col align="left" valign="top">
 485 <col>
 486 </colgroup>
 487 <tbody>
 488 <tr>
 489 <td><p><span class="term">Parameters:</span></p></td>
 490 <td><div class="variablelist"><table border="0" class="variablelist compact">
 491 <colgroup>
 492 <col align="left" valign="top">
 493 <col>
 494 </colgroup>
 495 <tbody><tr>
 496 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 497 <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>
 498 </tr></tbody>
 499 </table></div></td>
 500 </tr>
 501 <tr>
 502 <td><p><span class="term">Requires:</span></p></td>
 503 <td><p>C++ compiler with rvalue references support. </p></td>
 504 </tr>
 505 <tr>
 506 <td><p><span class="term">Postconditions:</span></p></td>
 507 <td><p><code class="computeroutput">cb.empty()</code> </p></td>
 508 </tr>
 509 <tr>
 510 <td><p><span class="term">Throws:</span></p></td>
 511 <td>Nothing. </td>
 512 </tr>
 513 </tbody>
 514 </table></div>
 515 </li>
 516 <li class="listitem">
 517 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 518   <a name="idm46495624207616-bb"></a><span class="identifier">circular_buffer</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>
 519                   <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> filled with a copy of the range. <p>
 520
 521
 522
 523 </p>
 524 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p>
 525 <p>
 526 </p>
 527 <div class="variablelist"><table border="0" class="variablelist compact">
 528 <colgroup>
 529 <col align="left" valign="top">
 530 <col>
 531 </colgroup>
 532 <tbody>
 533 <tr>
 534 <td><p><span class="term">Parameters:</span></p></td>
 535 <td><div class="variablelist"><table border="0" class="variablelist compact">
 536 <colgroup>
 537 <col align="left" valign="top">
 538 <col>
 539 </colgroup>
 540 <tbody>
 541 <tr>
 542 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 543 <td><p>The allocator. </p></td>
 544 </tr>
 545 <tr>
 546 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
 547 <td><p>The beginning of the range to be copied. </p></td>
 548 </tr>
 549 <tr>
 550 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
 551 <td><p>The end of the range to be copied. </p></td>
 552 </tr>
 553 </tbody>
 554 </table></div></td>
 555 </tr>
 556 <tr>
 557 <td><p><span class="term">Requires:</span></p></td>
 558 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
 559  <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>
 560 </tr>
 561 <tr>
 562 <td><p><span class="term">Postconditions:</span></p></td>
 563 <td><p><code class="computeroutput">capacity() == std::distance(first, last) &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> </p></td>
 564 </tr>
 565 <tr>
 566 <td><p><span class="term">Throws:</span></p></td>
 567 <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>
 568 </tr>
 569 </tbody>
 570 </table></div>
 571 </li>
 572 <li class="listitem">
 573 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 574   <a name="idm46495624194128-bb"></a><span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span>
 575                   <span class="identifier">InputIterator</span> last<span class="special">,</span>
 576                   <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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the specified capacity and filled with a copy of the range. <p>
 577
 578
 579
 580 </p>
 581 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[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>
 582 <p>
 583 </p>
 584 <div class="variablelist"><table border="0" class="variablelist compact">
 585 <colgroup>
 586 <col align="left" valign="top">
 587 <col>
 588 </colgroup>
 589 <tbody>
 590 <tr>
 591 <td><p><span class="term">Parameters:</span></p></td>
 592 <td><div class="variablelist"><table border="0" class="variablelist compact">
 593 <colgroup>
 594 <col align="left" valign="top">
 595 <col>
 596 </colgroup>
 597 <tbody>
 598 <tr>
 599 <td><p><span class="term"><code class="computeroutput">alloc</code></span></p></td>
 600 <td><p>The allocator. </p></td>
 601 </tr>
 602 <tr>
 603 <td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td>
 604 <td><p>The capacity of the created <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>
 605 </tr>
 606 <tr>
 607 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
 608 <td><p>The beginning of the range to be copied. </p></td>
 609 </tr>
 610 <tr>
 611 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
 612 <td><p>The end of the range to be copied. </p></td>
 613 </tr>
 614 </tbody>
 615 </table></div></td>
 616 </tr>
 617 <tr>
 618 <td><p><span class="term">Requires:</span></p></td>
 619 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
 620  <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>
 621 </tr>
 622 <tr>
 623 <td><p><span class="term">Postconditions:</span></p></td>
 624 <td><p><code class="computeroutput">capacity() == buffer_capacity &amp;&amp; size() &lt;= std::distance(first, last) &amp;&amp; (*this)[0]== *(last - buffer_capacity) &amp;&amp; (*this)[1] == *(last - buffer_capacity + 1) &amp;&amp; ... &amp;&amp; (*this)[buffer_capacity - 1] == *(last - 1)</code><br>
 625 <br>
 626  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">buffer_capacity</code> then only elements from the range <code class="computeroutput">[last - buffer_capacity, last)</code> will be copied. </p></td>
 627 </tr>
 628 <tr>
 629 <td><p><span class="term">Throws:</span></p></td>
 630 <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>
 631 </tr>
 632 </tbody>
 633 </table></div>
 634 </li>
 635 <li class="listitem">
 636 <pre class="literallayout"><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">&amp;</span>
 637 <a name="idm46495624166672-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_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">&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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to become a copy of the specified <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>.
 638
 639
 640 </p>
 641 <p><b>Exception Safety.&#160;</b>Strong. </p>
 642 <p>
 643 </p>
 644 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to this <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
 645 <p>
 646 </p>
 647 <p><b>Complexity.&#160;</b>Linear (in the size of <code class="computeroutput">cb</code>). </p>
 648 <p>
 649 </p>
 650 <p><span class="bold"><strong>See Also:</strong></span></p>
 651 <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>
 652 <p>
 653 </p>
 654 <p>
 655 </p>
 656 <div class="variablelist"><table border="0" class="variablelist compact">
 657 <colgroup>
 658 <col align="left" valign="top">
 659 <col>
 660 </colgroup>
 661 <tbody>
 662 <tr>
 663 <td><p><span class="term">Parameters:</span></p></td>
 664 <td><div class="variablelist"><table border="0" class="variablelist compact">
 665 <colgroup>
 666 <col align="left" valign="top">
 667 <col>
 668 </colgroup>
 669 <tbody><tr>
 670 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 671 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> to be copied. </p></td>
 672 </tr></tbody>
 673 </table></div></td>
 674 </tr>
 675 <tr>
 676 <td><p><span class="term">Postconditions:</span></p></td>
 677 <td><p><code class="computeroutput">*this == cb</code> </p></td>
 678 </tr>
 679 <tr>
 680 <td><p><span class="term">Throws:</span></p></td>
 681 <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>
 682 </tr>
 683 </tbody>
 684 </table></div>
 685 </li>
 686 <li class="listitem">
 687 <pre class="literallayout"><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">&amp;</span>
 688 <a name="idm46495624150592-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</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">&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>
 689
 690
 691
 692 </p>
 693 <p><b>Complexity.&#160;</b>Constant. </p>
 694 <p>
 695 </p>
 696 <div class="variablelist"><table border="0" class="variablelist compact">
 697 <colgroup>
 698 <col align="left" valign="top">
 699 <col>
 700 </colgroup>
 701 <tbody>
 702 <tr>
 703 <td><p><span class="term">Parameters:</span></p></td>
 704 <td><div class="variablelist"><table border="0" class="variablelist compact">
 705 <colgroup>
 706 <col align="left" valign="top">
 707 <col>
 708 </colgroup>
 709 <tbody><tr>
 710 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
 711 <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>
 712 </tr></tbody>
 713 </table></div></td>
 714 </tr>
 715 <tr>
 716 <td><p><span class="term">Requires:</span></p></td>
 717 <td><p>C++ compiler with rvalue references support. </p></td>
 718 </tr>
 719 <tr>
 720 <td><p><span class="term">Postconditions:</span></p></td>
 721 <td><p><code class="computeroutput">cb.empty()</code> </p></td>
 722 </tr>
 723 <tr>
 724 <td><p><span class="term">Throws:</span></p></td>
 725 <td>Nothing. </td>
 726 </tr>
 727 </tbody>
 728 </table></div>
 729 </li>
 730 <li class="listitem">
 731 <pre class="literallayout"><a name="idm46495624175088-bb"></a><span class="special">~</span><span class="identifier">circular_buffer</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>The destructor. <p>Destroys the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>.
 732 </p>
 733 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (including iterators equal to <code class="computeroutput">end()</code>). </p>
 734 <p>
 735 </p>
 736 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>) for scalar types; linear for other types. </p>
 737 <p>
 738 </p>
 739 <p><span class="bold"><strong>See Also:</strong></span></p>
 740 <p><code class="computeroutput">clear()</code> </p>
 741 <p>
 742 </p>
 743 <p>
 744 </p>
 745 <div class="variablelist"><table border="0" class="variablelist compact">
 746 <colgroup>
 747 <col align="left" valign="top">
 748 <col>
 749 </colgroup>
 750 <tbody><tr>
 751 <td><p><span class="term">Throws:</span></p></td>
 752 <td>Nothing. </td>
 753 </tr></tbody>
 754 </table></div>
 755 </li>
 756 </ol></div>
 757 </div>
 758 <div class="refsect2">
 759 <a name="id-1.3.9.16.3.3.4.6"></a><h3>
 760 <a name="idm46495625372432-bb"></a><code class="computeroutput">circular_buffer</code> public member functions</h3>
 761 <div class="orderedlist"><ol class="orderedlist" type="1">
 762 <li class="listitem">
 763 <pre class="literallayout"><span class="identifier">allocator_type</span> <a name="idm46495625371872-bb"></a><span class="identifier">get_allocator</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 allocator. <p>
 764
 765 </p>
 766 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 767 <p>
 768 </p>
 769 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 770 <p>
 771 </p>
 772 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 773 <p>
 774 </p>
 775 <p><span class="bold"><strong>See Also:</strong></span></p>
 776 <p><code class="computeroutput">get_allocator()</code> for obtaining an allocator reference. </p>
 777 <p>
 778 </p>
 779 <p>
 780 </p>
 781 <div class="variablelist"><table border="0" class="variablelist compact">
 782 <colgroup>
 783 <col align="left" valign="top">
 784 <col>
 785 </colgroup>
 786 <tbody>
 787 <tr>
 788 <td><p><span class="term">Returns:</span></p></td>
 789 <td><p>The allocator. </p></td>
 790 </tr>
 791 <tr>
 792 <td><p><span class="term">Throws:</span></p></td>
 793 <td>Nothing. </td>
 794 </tr>
 795 </tbody>
 796 </table></div>
 797 </li>
 798 <li class="listitem">
 799 <pre class="literallayout"><span class="identifier">allocator_type</span> <span class="special">&amp;</span> <a name="idm46495625363216-bb"></a><span class="identifier">get_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the allocator reference. <p>
 800
 801 </p>
 802 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 803 <p>
 804 </p>
 805 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 806 <p>
 807 </p>
 808 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 809 <p>
 810 </p>
 811 <div class="note"><table border="0" summary="Note">
 812 <tr>
 813 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
 814 <th align="left">Note</th>
 815 </tr>
 816 <tr><td align="left" valign="top"><p>This method was added in order to optimize obtaining of the allocator with a state, although use of stateful allocators in STL is discouraged. </p></td></tr>
 817 </table></div>
 818 <p>
 819 </p>
 820 <p><span class="bold"><strong>See Also:</strong></span></p>
 821 <p><code class="computeroutput">get_allocator() const</code> </p>
 822 <p>
 823 </p>
 824 <p>
 825 </p>
 826 <div class="variablelist"><table border="0" class="variablelist compact">
 827 <colgroup>
 828 <col align="left" valign="top">
 829 <col>
 830 </colgroup>
 831 <tbody>
 832 <tr>
 833 <td><p><span class="term">Returns:</span></p></td>
 834 <td><p>A reference to the allocator. </p></td>
 835 </tr>
 836 <tr>
 837 <td><p><span class="term">Throws:</span></p></td>
 838 <td>Nothing. </td>
 839 </tr>
 840 </tbody>
 841 </table></div>
 842 </li>
 843 <li class="listitem">
 844 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495625353680-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
 845
 846 </p>
 847 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 848 <p>
 849 </p>
 850 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 851 <p>
 852 </p>
 853 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 854 <p>
 855 </p>
 856 <p><span class="bold"><strong>See Also:</strong></span></p>
 857 <p><code class="computeroutput">end()</code>, <code class="computeroutput">rbegin()</code>, <code class="computeroutput">rend()</code> </p>
 858 <p>
 859 </p>
 860 <p>
 861 </p>
 862 <div class="variablelist"><table border="0" class="variablelist compact">
 863 <colgroup>
 864 <col align="left" valign="top">
 865 <col>
 866 </colgroup>
 867 <tbody>
 868 <tr>
 869 <td><p><span class="term">Returns:</span></p></td>
 870 <td><p>A random access iterator pointing to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">end()</code>. </p></td>
 871 </tr>
 872 <tr>
 873 <td><p><span class="term">Throws:</span></p></td>
 874 <td>Nothing. </td>
 875 </tr>
 876 </tbody>
 877 </table></div>
 878 </li>
 879 <li class="listitem">
 880 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495625341024-bb"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
 881
 882 </p>
 883 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 884 <p>
 885 </p>
 886 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 887 <p>
 888 </p>
 889 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 890 <p>
 891 </p>
 892 <p><span class="bold"><strong>See Also:</strong></span></p>
 893 <p><code class="computeroutput">begin()</code>, <code class="computeroutput">rbegin()</code>, <code class="computeroutput">rend()</code> </p>
 894 <p>
 895 </p>
 896 <p>
 897 </p>
 898 <div class="variablelist"><table border="0" class="variablelist compact">
 899 <colgroup>
 900 <col align="left" valign="top">
 901 <col>
 902 </colgroup>
 903 <tbody>
 904 <tr>
 905 <td><p><span class="term">Returns:</span></p></td>
 906 <td><p>A random access iterator pointing to the element "one behind" the last element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">begin()</code>. </p></td>
 907 </tr>
 908 <tr>
 909 <td><p><span class="term">Throws:</span></p></td>
 910 <td>Nothing. </td>
 911 </tr>
 912 </tbody>
 913 </table></div>
 914 </li>
 915 <li class="listitem">
 916 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm46495625328192-bb"></a><span class="identifier">begin</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 const iterator pointing to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
 917
 918 </p>
 919 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 920 <p>
 921 </p>
 922 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 923 <p>
 924 </p>
 925 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 926 <p>
 927 </p>
 928 <p><span class="bold"><strong>See Also:</strong></span></p>
 929 <p><code class="computeroutput">end() const</code>, <code class="computeroutput">rbegin() const</code>, <code class="computeroutput">rend() const</code> </p>
 930 <p>
 931 </p>
 932 <p>
 933 </p>
 934 <div class="variablelist"><table border="0" class="variablelist compact">
 935 <colgroup>
 936 <col align="left" valign="top">
 937 <col>
 938 </colgroup>
 939 <tbody>
 940 <tr>
 941 <td><p><span class="term">Returns:</span></p></td>
 942 <td><p>A const random access iterator pointing to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">end() const</code>. </p></td>
 943 </tr>
 944 <tr>
 945 <td><p><span class="term">Throws:</span></p></td>
 946 <td>Nothing. </td>
 947 </tr>
 948 </tbody>
 949 </table></div>
 950 </li>
 951 <li class="listitem">
 952 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm46495625315520-bb"></a><span class="identifier">end</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 const iterator pointing to the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
 953
 954 </p>
 955 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 956 <p>
 957 </p>
 958 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 959 <p>
 960 </p>
 961 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 962 <p>
 963 </p>
 964 <p><span class="bold"><strong>See Also:</strong></span></p>
 965 <p><code class="computeroutput">begin() const</code>, <code class="computeroutput">rbegin() const</code>, <code class="computeroutput">rend() const</code> </p>
 966 <p>
 967 </p>
 968 <p>
 969 </p>
 970 <div class="variablelist"><table border="0" class="variablelist compact">
 971 <colgroup>
 972 <col align="left" valign="top">
 973 <col>
 974 </colgroup>
 975 <tbody>
 976 <tr>
 977 <td><p><span class="term">Returns:</span></p></td>
 978 <td><p>A const random access iterator pointing to the element "one behind" the last element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">begin() const</code> const. </p></td>
 979 </tr>
 980 <tr>
 981 <td><p><span class="term">Throws:</span></p></td>
 982 <td>Nothing. </td>
 983 </tr>
 984 </tbody>
 985 </table></div>
 986 </li>
 987 <li class="listitem">
 988 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm46495625302672-bb"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the beginning of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
 989
 990 </p>
 991 <p><b>Exception Safety.&#160;</b>No-throw. </p>
 992 <p>
 993 </p>
 994 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
 995 <p>
 996 </p>
 997 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
 998 <p>
 999 </p>
1000 <p><span class="bold"><strong>See Also:</strong></span></p>
1001 <p><code class="computeroutput">rend()</code>, <code class="computeroutput">begin()</code>, <code class="computeroutput">end()</code> </p>
1002 <p>
1003 </p>
1004 <p>
1005 </p>
1006 <div class="variablelist"><table border="0" class="variablelist compact">
1007 <colgroup>
1008 <col align="left" valign="top">
1009 <col>
1010 </colgroup>
1011 <tbody>
1012 <tr>
1013 <td><p><span class="term">Returns:</span></p></td>
1014 <td><p>A reverse random access iterator pointing to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rend()</code>. </p></td>
1015 </tr>
1016 <tr>
1017 <td><p><span class="term">Throws:</span></p></td>
1018 <td>Nothing. </td>
1019 </tr>
1020 </tbody>
1021 </table></div>
1022 </li>
1023 <li class="listitem">
1024 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm46495625290000-bb"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Get the iterator pointing to the end of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
1025
1026 </p>
1027 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1028 <p>
1029 </p>
1030 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1031 <p>
1032 </p>
1033 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1034 <p>
1035 </p>
1036 <p><span class="bold"><strong>See Also:</strong></span></p>
1037 <p><code class="computeroutput">rbegin()</code>, <code class="computeroutput">begin()</code>, <code class="computeroutput">end()</code> </p>
1038 <p>
1039 </p>
1040 <p>
1041 </p>
1042 <div class="variablelist"><table border="0" class="variablelist compact">
1043 <colgroup>
1044 <col align="left" valign="top">
1045 <col>
1046 </colgroup>
1047 <tbody>
1048 <tr>
1049 <td><p><span class="term">Returns:</span></p></td>
1050 <td><p>A reverse random access iterator pointing to the element "one before" the first element of the <code class="computeroutput"> <a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rbegin()</code>. </p></td>
1051 </tr>
1052 <tr>
1053 <td><p><span class="term">Throws:</span></p></td>
1054 <td>Nothing. </td>
1055 </tr>
1056 </tbody>
1057 </table></div>
1058 </li>
1059 <li class="listitem">
1060 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm46495625277152-bb"></a><span class="identifier">rbegin</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 const iterator pointing to the beginning of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
1061
1062 </p>
1063 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1064 <p>
1065 </p>
1066 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1067 <p>
1068 </p>
1069 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1070 <p>
1071 </p>
1072 <p><span class="bold"><strong>See Also:</strong></span></p>
1073 <p><code class="computeroutput">rend() const</code>, <code class="computeroutput">begin() const</code>, <code class="computeroutput">end() const</code> </p>
1074 <p>
1075 </p>
1076 <p>
1077 </p>
1078 <div class="variablelist"><table border="0" class="variablelist compact">
1079 <colgroup>
1080 <col align="left" valign="top">
1081 <col>
1082 </colgroup>
1083 <tbody>
1084 <tr>
1085 <td><p><span class="term">Returns:</span></p></td>
1086 <td><p>A const reverse random access iterator pointing to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rend() const</code>. </p></td>
1087 </tr>
1088 <tr>
1089 <td><p><span class="term">Throws:</span></p></td>
1090 <td>Nothing. </td>
1091 </tr>
1092 </tbody>
1093 </table></div>
1094 </li>
1095 <li class="listitem">
1096 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm46495625264464-bb"></a><span class="identifier">rend</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 const iterator pointing to the end of the "reversed" <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
1097
1098 </p>
1099 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1100 <p>
1101 </p>
1102 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1103 <p>
1104 </p>
1105 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1106 <p>
1107 </p>
1108 <p><span class="bold"><strong>See Also:</strong></span></p>
1109 <p><code class="computeroutput">rbegin() const</code>, <code class="computeroutput">begin() const</code>, <code class="computeroutput">end() const</code> </p>
1110 <p>
1111 </p>
1112 <p>
1113 </p>
1114 <div class="variablelist"><table border="0" class="variablelist compact">
1115 <colgroup>
1116 <col align="left" valign="top">
1117 <col>
1118 </colgroup>
1119 <tbody>
1120 <tr>
1121 <td><p><span class="term">Returns:</span></p></td>
1122 <td><p>A const reverse random access iterator pointing to the element "one before" the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty it returns an iterator equal to the one returned by <code class="computeroutput">rbegin() const</code>. </p></td>
1123 </tr>
1124 <tr>
1125 <td><p><span class="term">Throws:</span></p></td>
1126 <td>Nothing. </td>
1127 </tr>
1128 </tbody>
1129 </table></div>
1130 </li>
1131 <li class="listitem">
1132 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm46495625251760-bb"></a><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p>
1133
1134
1135
1136 </p>
1137 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1138 <p>
1139 </p>
1140 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1141 <p>
1142 </p>
1143 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1144 <p>
1145 </p>
1146 <p><span class="bold"><strong>See Also:</strong></span></p>
1147 <p><code class="computeroutput">at()</code> </p>
1148 <p>
1149 </p>
1150 <p>
1151 </p>
1152 <div class="variablelist"><table border="0" class="variablelist compact">
1153 <colgroup>
1154 <col align="left" valign="top">
1155 <col>
1156 </colgroup>
1157 <tbody>
1158 <tr>
1159 <td><p><span class="term">Parameters:</span></p></td>
1160 <td><div class="variablelist"><table border="0" class="variablelist compact">
1161 <colgroup>
1162 <col align="left" valign="top">
1163 <col>
1164 </colgroup>
1165 <tbody><tr>
1166 <td><p><span class="term"><code class="computeroutput">index</code></span></p></td>
1167 <td><p>The position of the element. </p></td>
1168 </tr></tbody>
1169 </table></div></td>
1170 </tr>
1171 <tr>
1172 <td><p><span class="term">Requires:</span></p></td>
1173 <td><p><code class="computeroutput">0 &lt;= index &amp;&amp; index &lt; size()</code> </p></td>
1174 </tr>
1175 <tr>
1176 <td><p><span class="term">Returns:</span></p></td>
1177 <td><p>A reference to the element at the <code class="computeroutput">index</code> position. </p></td>
1178 </tr>
1179 <tr>
1180 <td><p><span class="term">Throws:</span></p></td>
1181 <td>Nothing. </td>
1182 </tr>
1183 </tbody>
1184 </table></div>
1185 </li>
1186 <li class="listitem">
1187 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm46495625240480-bb"></a><span class="keyword">operator</span> <span class="special">[</span><span class="special">]</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p>
1188
1189
1190
1191 </p>
1192 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1193 <p>
1194 </p>
1195 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1196 <p>
1197 </p>
1198 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1199 <p>
1200 </p>
1201 <p><span class="bold"><strong>See Also:</strong></span></p>
1202 <p><code class="computeroutput">at() const </code> </p>
1203 <p>
1204 </p>
1205 <p>
1206 </p>
1207 <div class="variablelist"><table border="0" class="variablelist compact">
1208 <colgroup>
1209 <col align="left" valign="top">
1210 <col>
1211 </colgroup>
1212 <tbody>
1213 <tr>
1214 <td><p><span class="term">Parameters:</span></p></td>
1215 <td><div class="variablelist"><table border="0" class="variablelist compact">
1216 <colgroup>
1217 <col align="left" valign="top">
1218 <col>
1219 </colgroup>
1220 <tbody><tr>
1221 <td><p><span class="term"><code class="computeroutput">index</code></span></p></td>
1222 <td><p>The position of the element. </p></td>
1223 </tr></tbody>
1224 </table></div></td>
1225 </tr>
1226 <tr>
1227 <td><p><span class="term">Requires:</span></p></td>
1228 <td><p><code class="computeroutput">0 &lt;= index &amp;&amp; index &lt; size()</code> </p></td>
1229 </tr>
1230 <tr>
1231 <td><p><span class="term">Returns:</span></p></td>
1232 <td><p>A const reference to the element at the <code class="computeroutput">index</code> position. </p></td>
1233 </tr>
1234 <tr>
1235 <td><p><span class="term">Throws:</span></p></td>
1236 <td>Nothing. </td>
1237 </tr>
1238 </tbody>
1239 </table></div>
1240 </li>
1241 <li class="listitem">
1242 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm46495625228912-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p>
1243
1244
1245 </p>
1246 <p><b>Exception Safety.&#160;</b>Strong. </p>
1247 <p>
1248 </p>
1249 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1250 <p>
1251 </p>
1252 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1253 <p>
1254 </p>
1255 <p><span class="bold"><strong>See Also:</strong></span></p>
1256 <p><code class="computeroutput">operator[] </code> </p>
1257 <p>
1258 </p>
1259 <p>
1260 </p>
1261 <div class="variablelist"><table border="0" class="variablelist compact">
1262 <colgroup>
1263 <col align="left" valign="top">
1264 <col>
1265 </colgroup>
1266 <tbody>
1267 <tr>
1268 <td><p><span class="term">Parameters:</span></p></td>
1269 <td><div class="variablelist"><table border="0" class="variablelist compact">
1270 <colgroup>
1271 <col align="left" valign="top">
1272 <col>
1273 </colgroup>
1274 <tbody><tr>
1275 <td><p><span class="term"><code class="computeroutput">index</code></span></p></td>
1276 <td><p>The position of the element. </p></td>
1277 </tr></tbody>
1278 </table></div></td>
1279 </tr>
1280 <tr>
1281 <td><p><span class="term">Returns:</span></p></td>
1282 <td><p>A reference to the element at the <code class="computeroutput">index</code> position. </p></td>
1283 </tr>
1284 <tr>
1285 <td><p><span class="term">Throws:</span></p></td>
1286 <td>&lt;code&gt;std::out_of_range&lt;/code&gt; when the <code class="computeroutput">index</code> is invalid (when <code class="computeroutput">index &gt;= size()</code>). </td>
1287 </tr>
1288 </tbody>
1289 </table></div>
1290 </li>
1291 <li class="listitem">
1292 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm46495625217600-bb"></a><span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> index<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the element at the <code class="computeroutput">index</code> position. <p>
1293
1294
1295 </p>
1296 <p><b>Exception Safety.&#160;</b>Strong. </p>
1297 <p>
1298 </p>
1299 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1300 <p>
1301 </p>
1302 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1303 <p>
1304 </p>
1305 <p><span class="bold"><strong>See Also:</strong></span></p>
1306 <p><code class="computeroutput">operator[] const </code> </p>
1307 <p>
1308 </p>
1309 <p>
1310 </p>
1311 <div class="variablelist"><table border="0" class="variablelist compact">
1312 <colgroup>
1313 <col align="left" valign="top">
1314 <col>
1315 </colgroup>
1316 <tbody>
1317 <tr>
1318 <td><p><span class="term">Parameters:</span></p></td>
1319 <td><div class="variablelist"><table border="0" class="variablelist compact">
1320 <colgroup>
1321 <col align="left" valign="top">
1322 <col>
1323 </colgroup>
1324 <tbody><tr>
1325 <td><p><span class="term"><code class="computeroutput">index</code></span></p></td>
1326 <td><p>The position of the element. </p></td>
1327 </tr></tbody>
1328 </table></div></td>
1329 </tr>
1330 <tr>
1331 <td><p><span class="term">Returns:</span></p></td>
1332 <td><p>A const reference to the element at the <code class="computeroutput">index</code> position. </p></td>
1333 </tr>
1334 <tr>
1335 <td><p><span class="term">Throws:</span></p></td>
1336 <td>&lt;code&gt;std::out_of_range&lt;/code&gt; when the <code class="computeroutput">index</code> is invalid (when <code class="computeroutput">index &gt;= size()</code>). </td>
1337 </tr>
1338 </tbody>
1339 </table></div>
1340 </li>
1341 <li class="listitem">
1342 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm46495625206000-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the first element. <p>
1343
1344
1345 </p>
1346 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1347 <p>
1348 </p>
1349 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1350 <p>
1351 </p>
1352 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1353 <p>
1354 </p>
1355 <p><span class="bold"><strong>See Also:</strong></span></p>
1356 <p><code class="computeroutput">back()</code> </p>
1357 <p>
1358 </p>
1359 <p>
1360 </p>
1361 <div class="variablelist"><table border="0" class="variablelist compact">
1362 <colgroup>
1363 <col align="left" valign="top">
1364 <col>
1365 </colgroup>
1366 <tbody>
1367 <tr>
1368 <td><p><span class="term">Requires:</span></p></td>
1369 <td><p><code class="computeroutput">!empty()</code> </p></td>
1370 </tr>
1371 <tr>
1372 <td><p><span class="term">Returns:</span></p></td>
1373 <td><p>A reference to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
1374 </tr>
1375 <tr>
1376 <td><p><span class="term">Throws:</span></p></td>
1377 <td>Nothing. </td>
1378 </tr>
1379 </tbody>
1380 </table></div>
1381 </li>
1382 <li class="listitem">
1383 <pre class="literallayout"><span class="identifier">reference</span> <a name="idm46495625195888-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the last element. <p>
1384
1385
1386 </p>
1387 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1388 <p>
1389 </p>
1390 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1391 <p>
1392 </p>
1393 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1394 <p>
1395 </p>
1396 <p><span class="bold"><strong>See Also:</strong></span></p>
1397 <p><code class="computeroutput">front()</code> </p>
1398 <p>
1399 </p>
1400 <p>
1401 </p>
1402 <div class="variablelist"><table border="0" class="variablelist compact">
1403 <colgroup>
1404 <col align="left" valign="top">
1405 <col>
1406 </colgroup>
1407 <tbody>
1408 <tr>
1409 <td><p><span class="term">Requires:</span></p></td>
1410 <td><p><code class="computeroutput">!empty()</code> </p></td>
1411 </tr>
1412 <tr>
1413 <td><p><span class="term">Returns:</span></p></td>
1414 <td><p>A reference to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
1415 </tr>
1416 <tr>
1417 <td><p><span class="term">Throws:</span></p></td>
1418 <td>Nothing. </td>
1419 </tr>
1420 </tbody>
1421 </table></div>
1422 </li>
1423 <li class="listitem">
1424 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm46495625185792-bb"></a><span class="identifier">front</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the first element. <p>
1425
1426
1427 </p>
1428 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1429 <p>
1430 </p>
1431 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1432 <p>
1433 </p>
1434 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1435 <p>
1436 </p>
1437 <p><span class="bold"><strong>See Also:</strong></span></p>
1438 <p><code class="computeroutput">back() const</code> </p>
1439 <p>
1440 </p>
1441 <p>
1442 </p>
1443 <div class="variablelist"><table border="0" class="variablelist compact">
1444 <colgroup>
1445 <col align="left" valign="top">
1446 <col>
1447 </colgroup>
1448 <tbody>
1449 <tr>
1450 <td><p><span class="term">Requires:</span></p></td>
1451 <td><p><code class="computeroutput">!empty()</code> </p></td>
1452 </tr>
1453 <tr>
1454 <td><p><span class="term">Returns:</span></p></td>
1455 <td><p>A const reference to the first element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
1456 </tr>
1457 <tr>
1458 <td><p><span class="term">Throws:</span></p></td>
1459 <td>Nothing. </td>
1460 </tr>
1461 </tbody>
1462 </table></div>
1463 </li>
1464 <li class="listitem">
1465 <pre class="literallayout"><span class="identifier">const_reference</span> <a name="idm46495625175408-bb"></a><span class="identifier">back</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the last element. <p>
1466
1467
1468 </p>
1469 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1470 <p>
1471 </p>
1472 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1473 <p>
1474 </p>
1475 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1476 <p>
1477 </p>
1478 <p><span class="bold"><strong>See Also:</strong></span></p>
1479 <p><code class="computeroutput">front() const</code> </p>
1480 <p>
1481 </p>
1482 <p>
1483 </p>
1484 <div class="variablelist"><table border="0" class="variablelist compact">
1485 <colgroup>
1486 <col align="left" valign="top">
1487 <col>
1488 </colgroup>
1489 <tbody>
1490 <tr>
1491 <td><p><span class="term">Requires:</span></p></td>
1492 <td><p><code class="computeroutput">!empty()</code> </p></td>
1493 </tr>
1494 <tr>
1495 <td><p><span class="term">Returns:</span></p></td>
1496 <td><p>A const reference to the last element of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
1497 </tr>
1498 <tr>
1499 <td><p><span class="term">Throws:</span></p></td>
1500 <td>Nothing. </td>
1501 </tr>
1502 </tbody>
1503 </table></div>
1504 </li>
1505 <li class="listitem">
1506 <pre class="literallayout"><span class="identifier">array_range</span> <a name="idm46495625165024-bb"></a><span class="identifier">array_one</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the first continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_two()</code> can be useful when passing the stored data into a legacy C API as an array. Suppose there is a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> of capacity 10, containing 7 characters <code class="computeroutput">'a', 'b', ..., 'g'</code> where <code class="computeroutput">buff[0] == 'a'</code>, <code class="computeroutput">buff[1] == 'b'</code>, ... and <code class="computeroutput">buff[6] == 'g'</code>:<br>
1507 <br>
1508  <code class="computeroutput">circular_buffer&lt;char&gt; buff(10);</code><br>
1509 <br>
1510  The internal representation is often not linear and the state of the internal buffer may look like this:<br>
1511  <br>
1512 <code class="computeroutput"> |e|f|g| | | |a|b|c|d|<br>
1513  end ___^<br>
1514  begin _______^</code><br>
1515 <br>
1516 </p>
1517 <p>where <code class="computeroutput">|a|b|c|d|</code> represents the "array one", <code class="computeroutput">|e|f|g|</code> represents the "array two" and <code class="computeroutput">| | | |</code> is a free space.<br>
1518  Now consider a typical C style function for writing data into a file:<br>
1519 <br>
1520  <code class="computeroutput">int write(int file_desc, char* buff, int num_bytes);</code><br>
1521 <br>
1522  There are two ways how to write the content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> into a file. Either relying on <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> methods and calling the write function twice:<br>
1523 <br>
1524  <code class="computeroutput">array_range ar = buff.array_one();<br>
1525  write(file_desc, ar.first, ar.second);<br>
1526  ar = buff.array_two();<br>
1527  write(file_desc, ar.first, ar.second);</code><br>
1528 <br>
1529  Or relying on the <code class="computeroutput">linearize()</code> method:<br>
1530 <br>
1531 <code class="computeroutput"> write(file_desc, buff.linearize(), buff.size());</code><br>
1532 <br>
1533  Since the complexity of <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> methods is constant the first option is suitable when calling the write method is "cheap". On the other hand the second option is more suitable when calling the write method is more "expensive" than calling the <code class="computeroutput">linearize()</code> method whose complexity is linear.
1534
1535 </p>
1536 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1537 <p>
1538 </p>
1539 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1540 <p>
1541 </p>
1542 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1543 <p>
1544 </p>
1545 <div class="warning"><table border="0" summary="Warning">
1546 <tr>
1547 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
1548 <th align="left">Warning</th>
1549 </tr>
1550 <tr><td align="left" valign="top"><p>In general invoking any method which modifies the internal state of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> may delinearize the internal buffer and invalidate the array ranges returned by <code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> (and their const versions). </p></td></tr>
1551 </table></div>
1552 <p>
1553 </p>
1554 <div class="note"><table border="0" summary="Note">
1555 <tr>
1556 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
1557 <th align="left">Note</th>
1558 </tr>
1559 <tr><td align="left" valign="top"><p>In the case the internal buffer is linear e.g. <code class="computeroutput">|a|b|c|d|e|f|g| | | |</code> the "array one" is represented by <code class="computeroutput">|a|b|c|d|e|f|g|</code> and the "array two" does not exist (the <code class="computeroutput">array_two()</code> method returns an array with the size <code class="computeroutput">0</code>). </p></td></tr>
1560 </table></div>
1561 <p>
1562 </p>
1563 <p><span class="bold"><strong>See Also:</strong></span></p>
1564 <p><code class="computeroutput">array_two()</code>, <code class="computeroutput">linearize()</code> </p>
1565 <p>
1566 </p>
1567 <p>
1568 </p>
1569 <div class="variablelist"><table border="0" class="variablelist compact">
1570 <colgroup>
1571 <col align="left" valign="top">
1572 <col>
1573 </colgroup>
1574 <tbody>
1575 <tr>
1576 <td><p><span class="term">Returns:</span></p></td>
1577 <td><p>The array range of the first continuous array of the internal buffer. In the case the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td>
1578 </tr>
1579 <tr>
1580 <td><p><span class="term">Throws:</span></p></td>
1581 <td>Nothing. </td>
1582 </tr>
1583 </tbody>
1584 </table></div>
1585 </li>
1586 <li class="listitem">
1587 <pre class="literallayout"><span class="identifier">array_range</span> <a name="idm46495625131696-bb"></a><span class="identifier">array_two</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the second continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_one()</code> can be useful when passing the stored data into a legacy C API as an array.
1588
1589 </p>
1590 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1591 <p>
1592 </p>
1593 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1594 <p>
1595 </p>
1596 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1597 <p>
1598 </p>
1599 <p><span class="bold"><strong>See Also:</strong></span></p>
1600 <p><code class="computeroutput">array_one()</code> </p>
1601 <p>
1602 </p>
1603 <p>
1604 </p>
1605 <div class="variablelist"><table border="0" class="variablelist compact">
1606 <colgroup>
1607 <col align="left" valign="top">
1608 <col>
1609 </colgroup>
1610 <tbody>
1611 <tr>
1612 <td><p><span class="term">Returns:</span></p></td>
1613 <td><p>The array range of the second continuous array of the internal buffer. In the case the internal buffer is linear or the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td>
1614 </tr>
1615 <tr>
1616 <td><p><span class="term">Throws:</span></p></td>
1617 <td>Nothing. </td>
1618 </tr>
1619 </tbody>
1620 </table></div>
1621 </li>
1622 <li class="listitem">
1623 <pre class="literallayout"><span class="identifier">const_array_range</span> <a name="idm46495625121312-bb"></a><span class="identifier">array_one</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the first continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_two() const</code> can be useful when passing the stored data into a legacy C API as an array.
1624
1625 </p>
1626 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1627 <p>
1628 </p>
1629 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1630 <p>
1631 </p>
1632 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1633 <p>
1634 </p>
1635 <p><span class="bold"><strong>See Also:</strong></span></p>
1636 <p><code class="computeroutput">array_two() const</code>; <code class="computeroutput">array_one()</code> for more details how to pass data into a legacy C API. </p>
1637 <p>
1638 </p>
1639 <p>
1640 </p>
1641 <div class="variablelist"><table border="0" class="variablelist compact">
1642 <colgroup>
1643 <col align="left" valign="top">
1644 <col>
1645 </colgroup>
1646 <tbody>
1647 <tr>
1648 <td><p><span class="term">Returns:</span></p></td>
1649 <td><p>The array range of the first continuous array of the internal buffer. In the case the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td>
1650 </tr>
1651 <tr>
1652 <td><p><span class="term">Throws:</span></p></td>
1653 <td>Nothing. </td>
1654 </tr>
1655 </tbody>
1656 </table></div>
1657 </li>
1658 <li class="listitem">
1659 <pre class="literallayout"><span class="identifier">const_array_range</span> <a name="idm46495625110224-bb"></a><span class="identifier">array_two</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Get the second continuous array of the internal buffer. <p>This method in combination with <code class="computeroutput">array_one() const</code> can be useful when passing the stored data into a legacy C API as an array.
1660
1661 </p>
1662 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1663 <p>
1664 </p>
1665 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1666 <p>
1667 </p>
1668 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1669 <p>
1670 </p>
1671 <p><span class="bold"><strong>See Also:</strong></span></p>
1672 <p><code class="computeroutput">array_one() const</code> </p>
1673 <p>
1674 </p>
1675 <p>
1676 </p>
1677 <div class="variablelist"><table border="0" class="variablelist compact">
1678 <colgroup>
1679 <col align="left" valign="top">
1680 <col>
1681 </colgroup>
1682 <tbody>
1683 <tr>
1684 <td><p><span class="term">Returns:</span></p></td>
1685 <td><p>The array range of the second continuous array of the internal buffer. In the case the internal buffer is linear or the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is empty the size of the returned array is <code class="computeroutput">0</code>. </p></td>
1686 </tr>
1687 <tr>
1688 <td><p><span class="term">Throws:</span></p></td>
1689 <td>Nothing. </td>
1690 </tr>
1691 </tbody>
1692 </table></div>
1693 </li>
1694 <li class="listitem">
1695 <pre class="literallayout"><span class="identifier">pointer</span> <a name="idm46495625099568-bb"></a><span class="identifier">linearize</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Linearize the internal buffer into a continuous array. <p>This method can be useful when passing the stored data into a legacy C API as an array.
1696
1697
1698 </p>
1699 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
1700 <p>
1701 </p>
1702 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>); does not invalidate any iterators if the postcondition (the <span class="emphasis"><em>Effect</em></span>) is already met prior calling this method. </p>
1703 <p>
1704 </p>
1705 <p><b>Complexity.&#160;</b>Linear (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>); constant if the postcondition (the <span class="emphasis"><em>Effect</em></span>) is already met. </p>
1706 <p>
1707 </p>
1708 <div class="warning"><table border="0" summary="Warning">
1709 <tr>
1710 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../doc/src/images/warning.png"></td>
1711 <th align="left">Warning</th>
1712 </tr>
1713 <tr><td align="left" valign="top"><p>In general invoking any method which modifies the internal state of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> may delinearize the internal buffer and invalidate the returned pointer. </p></td></tr>
1714 </table></div>
1715 <p>
1716 </p>
1717 <p><span class="bold"><strong>See Also:</strong></span></p>
1718 <p><code class="computeroutput">array_one()</code> and <code class="computeroutput">array_two()</code> for the other option how to pass data into a legacy C API; <code class="computeroutput">is_linearized()</code>, <code class="computeroutput">rotate(const_iterator)</code> </p>
1719 <p>
1720 </p>
1721 <p>
1722 </p>
1723 <div class="variablelist"><table border="0" class="variablelist compact">
1724 <colgroup>
1725 <col align="left" valign="top">
1726 <col>
1727 </colgroup>
1728 <tbody>
1729 <tr>
1730 <td><p><span class="term">Postconditions:</span></p></td>
1731 <td><p><code class="computeroutput">&amp;(*this)[0] &lt; &amp;(*this)[1] &lt; ... &lt; &amp;(*this)[size() - 1]</code> </p></td>
1732 </tr>
1733 <tr>
1734 <td><p><span class="term">Returns:</span></p></td>
1735 <td><p>A pointer to the beginning of the array or <code class="computeroutput">0</code> if empty. </p></td>
1736 </tr>
1737 <tr>
1738 <td><p><span class="term">Throws:</span></p></td>
1739 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
1740 </tr>
1741 </tbody>
1742 </table></div>
1743 </li>
1744 <li class="listitem">
1745 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm46495625083664-bb"></a><span class="identifier">is_linearized</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> linearized? <p>
1746
1747 </p>
1748 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1749 <p>
1750 </p>
1751 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1752 <p>
1753 </p>
1754 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1755 <p>
1756 </p>
1757 <p><span class="bold"><strong>See Also:</strong></span></p>
1758 <p><code class="computeroutput">linearize()</code>, <code class="computeroutput">array_one()</code>, <code class="computeroutput">array_two()</code> </p>
1759 <p>
1760 </p>
1761 <p>
1762 </p>
1763 <div class="variablelist"><table border="0" class="variablelist compact">
1764 <colgroup>
1765 <col align="left" valign="top">
1766 <col>
1767 </colgroup>
1768 <tbody>
1769 <tr>
1770 <td><p><span class="term">Returns:</span></p></td>
1771 <td><p><code class="computeroutput">true</code> if the internal buffer is linearized into a continuous array (i.e. the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> meets a condition <code class="computeroutput">&amp;(*this)[0] &lt; &amp;(*this)[1] &lt; ... &lt; &amp;(*this)[size() - 1]</code>); <code class="computeroutput">false</code> otherwise. </p></td>
1772 </tr>
1773 <tr>
1774 <td><p><span class="term">Throws:</span></p></td>
1775 <td>Nothing. </td>
1776 </tr>
1777 </tbody>
1778 </table></div>
1779 </li>
1780 <li class="listitem">
1781 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495625071152-bb"></a><span class="identifier">rotate</span><span class="special">(</span><span class="identifier">const_iterator</span> new_begin<span class="special">)</span><span class="special">;</span></pre>Rotate elements in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>A more effective implementation of <code class="computeroutput"><a href="https://www.boost.org/sgi/stl/rotate.html" target="_top">std::rotate</a></code>.
1782
1783
1784
1785 </p>
1786 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full or <code class="computeroutput">new_begin</code> points to <code class="computeroutput">begin()</code> or if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
1787 <p>
1788 </p>
1789 <p><b>Iterator Invalidation.&#160;</b>If <code class="computeroutput">m &lt; n</code> invalidates iterators pointing to the last <code class="computeroutput">m</code> elements (<span class="bold"><strong>including</strong></span> <code class="computeroutput">new_begin</code>, but not iterators equal to <code class="computeroutput">end()</code>) else invalidates iterators pointing to the first <code class="computeroutput">n</code> elements; does not invalidate any iterators if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full. </p>
1790 <p>
1791 </p>
1792 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">(std::min)(m, n)</code>); constant if the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> is full. </p>
1793 <p>
1794 </p>
1795 <p><span class="bold"><strong>See Also:</strong></span></p>
1796 <p><code class="computeroutput"><a href="https://www.boost.org/sgi/stl/rotate.html" target="_top">std::rotate</a></code> </p>
1797 <p>
1798 </p>
1799 <p>
1800 </p>
1801 <div class="variablelist"><table border="0" class="variablelist compact">
1802 <colgroup>
1803 <col align="left" valign="top">
1804 <col>
1805 </colgroup>
1806 <tbody>
1807 <tr>
1808 <td><p><span class="term">Parameters:</span></p></td>
1809 <td><div class="variablelist"><table border="0" class="variablelist compact">
1810 <colgroup>
1811 <col align="left" valign="top">
1812 <col>
1813 </colgroup>
1814 <tbody><tr>
1815 <td><p><span class="term"><code class="computeroutput">new_begin</code></span></p></td>
1816 <td><p>The new beginning. </p></td>
1817 </tr></tbody>
1818 </table></div></td>
1819 </tr>
1820 <tr>
1821 <td><p><span class="term">Requires:</span></p></td>
1822 <td><p><code class="computeroutput">new_begin</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> <span class="bold"><strong>except</strong></span> its end. </p></td>
1823 </tr>
1824 <tr>
1825 <td><p><span class="term">Postconditions:</span></p></td>
1826 <td><p>Before calling the method suppose:<br>
1827 <br>
1828  <code class="computeroutput">m == std::distance(new_begin, end())</code><br>
1829 <code class="computeroutput">n == std::distance(begin(), new_begin)</code> <br>
1830 <code class="computeroutput">val_0 == *new_begin, val_1 == *(new_begin + 1), ... val_m == *(new_begin + m)</code><br>
1831  <code class="computeroutput">val_r1 == *(new_begin - 1), val_r2 == *(new_begin - 2), ... val_rn == *(new_begin - n)</code><br>
1832  <br>
1833 then after call to the method:<br>
1834 <br>
1835  <code class="computeroutput">val_0 == (*this)[0] &amp;&amp; val_1 == (*this)[1] &amp;&amp; ... &amp;&amp; val_m == (*this)[m - 1] &amp;&amp; val_r1 == (*this)[m + n - 1] &amp;&amp; val_r2 == (*this)[m + n - 2] &amp;&amp; ... &amp;&amp; val_rn == (*this)[m]</code> </p></td>
1836 </tr>
1837 <tr>
1838 <td><p><span class="term">Throws:</span></p></td>
1839 <td>See <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
1840 </tr>
1841 </tbody>
1842 </table></div>
1843 </li>
1844 <li class="listitem">
1845 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm46495625044976-bb"></a><span class="identifier">size</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 number of elements currently stored in the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
1846
1847 </p>
1848 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1849 <p>
1850 </p>
1851 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1852 <p>
1853 </p>
1854 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1855 <p>
1856 </p>
1857 <p><span class="bold"><strong>See Also:</strong></span></p>
1858 <p><code class="computeroutput">capacity()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">reserve()</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p>
1859 <p>
1860 </p>
1861 <p>
1862 </p>
1863 <div class="variablelist"><table border="0" class="variablelist compact">
1864 <colgroup>
1865 <col align="left" valign="top">
1866 <col>
1867 </colgroup>
1868 <tbody>
1869 <tr>
1870 <td><p><span class="term">Returns:</span></p></td>
1871 <td><p>The number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
1872 </tr>
1873 <tr>
1874 <td><p><span class="term">Throws:</span></p></td>
1875 <td>Nothing. </td>
1876 </tr>
1877 </tbody>
1878 </table></div>
1879 </li>
1880 <li class="listitem">
1881 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm46495625033232-bb"></a><span class="identifier">max_size</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 largest possible size or capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. (It depends on allocator's max_size()). <p>
1882
1883 </p>
1884 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1885 <p>
1886 </p>
1887 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1888 <p>
1889 </p>
1890 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1891 <p>
1892 </p>
1893 <p><span class="bold"><strong>See Also:</strong></span></p>
1894 <p><code class="computeroutput">size()</code>, <code class="computeroutput">capacity()</code>, <code class="computeroutput">reserve()</code> </p>
1895 <p>
1896 </p>
1897 <p>
1898 </p>
1899 <div class="variablelist"><table border="0" class="variablelist compact">
1900 <colgroup>
1901 <col align="left" valign="top">
1902 <col>
1903 </colgroup>
1904 <tbody>
1905 <tr>
1906 <td><p><span class="term">Returns:</span></p></td>
1907 <td><p>The maximum size/capacity the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> can be set to. </p></td>
1908 </tr>
1909 <tr>
1910 <td><p><span class="term">Throws:</span></p></td>
1911 <td>Nothing. </td>
1912 </tr>
1913 </tbody>
1914 </table></div>
1915 </li>
1916 <li class="listitem">
1917 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm46495625021920-bb"></a><span class="identifier">empty</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> empty? <p>
1918
1919 </p>
1920 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1921 <p>
1922 </p>
1923 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1924 <p>
1925 </p>
1926 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1927 <p>
1928 </p>
1929 <p><span class="bold"><strong>See Also:</strong></span></p>
1930 <p><code class="computeroutput">full()</code> </p>
1931 <p>
1932 </p>
1933 <p>
1934 </p>
1935 <div class="variablelist"><table border="0" class="variablelist compact">
1936 <colgroup>
1937 <col align="left" valign="top">
1938 <col>
1939 </colgroup>
1940 <tbody>
1941 <tr>
1942 <td><p><span class="term">Returns:</span></p></td>
1943 <td><p><code class="computeroutput">true</code> if there are no elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>; <code class="computeroutput">false</code> otherwise. </p></td>
1944 </tr>
1945 <tr>
1946 <td><p><span class="term">Throws:</span></p></td>
1947 <td>Nothing. </td>
1948 </tr>
1949 </tbody>
1950 </table></div>
1951 </li>
1952 <li class="listitem">
1953 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm46495625010816-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> full? <p>
1954
1955 </p>
1956 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1957 <p>
1958 </p>
1959 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1960 <p>
1961 </p>
1962 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1963 <p>
1964 </p>
1965 <p><span class="bold"><strong>See Also:</strong></span></p>
1966 <p><code class="computeroutput">empty()</code> </p>
1967 <p>
1968 </p>
1969 <p>
1970 </p>
1971 <div class="variablelist"><table border="0" class="variablelist compact">
1972 <colgroup>
1973 <col align="left" valign="top">
1974 <col>
1975 </colgroup>
1976 <tbody>
1977 <tr>
1978 <td><p><span class="term">Returns:</span></p></td>
1979 <td><p><code class="computeroutput">true</code> if the number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> equals the capacity of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>; <code class="computeroutput">false</code> otherwise. </p></td>
1980 </tr>
1981 <tr>
1982 <td><p><span class="term">Throws:</span></p></td>
1983 <td>Nothing. </td>
1984 </tr>
1985 </tbody>
1986 </table></div>
1987 </li>
1988 <li class="listitem">
1989 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm46495624998848-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> without overwriting any of already stored elements. <p>
1990
1991 </p>
1992 <p><b>Exception Safety.&#160;</b>No-throw. </p>
1993 <p>
1994 </p>
1995 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
1996 <p>
1997 </p>
1998 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
1999 <p>
2000 </p>
2001 <p><span class="bold"><strong>See Also:</strong></span></p>
2002 <p><code class="computeroutput">capacity()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code> </p>
2003 <p>
2004 </p>
2005 <p>
2006 </p>
2007 <div class="variablelist"><table border="0" class="variablelist compact">
2008 <colgroup>
2009 <col align="left" valign="top">
2010 <col>
2011 </colgroup>
2012 <tbody>
2013 <tr>
2014 <td><p><span class="term">Returns:</span></p></td>
2015 <td><p><code class="computeroutput">capacity() - size()</code> </p></td>
2016 </tr>
2017 <tr>
2018 <td><p><span class="term">Throws:</span></p></td>
2019 <td>Nothing. </td>
2020 </tr>
2021 </tbody>
2022 </table></div>
2023 </li>
2024 <li class="listitem">
2025 <pre class="literallayout"><span class="identifier">capacity_type</span> <a name="idm46495624988096-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2026
2027 </p>
2028 <p><b>Exception Safety.&#160;</b>No-throw. </p>
2029 <p>
2030 </p>
2031 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators. </p>
2032 <p>
2033 </p>
2034 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2035 <p>
2036 </p>
2037 <p><span class="bold"><strong>See Also:</strong></span></p>
2038 <p><code class="computeroutput">reserve()</code>, <code class="computeroutput">size()</code>, <code class="computeroutput">max_size()</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p>
2039 <p>
2040 </p>
2041 <p>
2042 </p>
2043 <div class="variablelist"><table border="0" class="variablelist compact">
2044 <colgroup>
2045 <col align="left" valign="top">
2046 <col>
2047 </colgroup>
2048 <tbody>
2049 <tr>
2050 <td><p><span class="term">Returns:</span></p></td>
2051 <td><p>The maximum number of elements which can be stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
2052 </tr>
2053 <tr>
2054 <td><p><span class="term">Throws:</span></p></td>
2055 <td>Nothing. </td>
2056 </tr>
2057 </tbody>
2058 </table></div>
2059 </li>
2060 <li class="listitem">
2061 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624976336-bb"></a><span class="identifier">set_capacity</span><span class="special">(</span><span class="identifier">capacity_type</span> new_capacity<span class="special">)</span><span class="special">;</span></pre>Change the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2062
2063
2064
2065 </p>
2066 <p><b>Exception Safety.&#160;</b>Strong. </p>
2067 <p>
2068 </p>
2069 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new capacity is different from the original. </p>
2070 <p>
2071 </p>
2072 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[size(), new_capacity]</code>). </p>
2073 <p>
2074 </p>
2075 <p><span class="bold"><strong>See Also:</strong></span></p>
2076 <p><code class="computeroutput">rset_capacity(capacity_type)</code>, <code class="computeroutput">resize(size_type, const_reference)</code> </p>
2077 <p>
2078 </p>
2079 <p>
2080 </p>
2081 <div class="variablelist"><table border="0" class="variablelist compact">
2082 <colgroup>
2083 <col align="left" valign="top">
2084 <col>
2085 </colgroup>
2086 <tbody>
2087 <tr>
2088 <td><p><span class="term">Parameters:</span></p></td>
2089 <td><div class="variablelist"><table border="0" class="variablelist compact">
2090 <colgroup>
2091 <col align="left" valign="top">
2092 <col>
2093 </colgroup>
2094 <tbody><tr>
2095 <td><p><span class="term"><code class="computeroutput">new_capacity</code></span></p></td>
2096 <td><p>The new capacity. </p></td>
2097 </tr></tbody>
2098 </table></div></td>
2099 </tr>
2100 <tr>
2101 <td><p><span class="term">Requires:</span></p></td>
2102 <td><p>If <code class="computeroutput">T</code> is a move only type, then compiler shall support <code class="computeroutput">noexcept</code> modifiers and move constructor of <code class="computeroutput">T</code> must be marked with it (must not throw exceptions). </p></td>
2103 </tr>
2104 <tr>
2105 <td><p><span class="term">Postconditions:</span></p></td>
2106 <td><p><code class="computeroutput">capacity() == new_capacity &amp;&amp; size() &lt;= new_capacity</code><br>
2107 <br>
2108  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - new_capacity]</code> <span class="bold"><strong>last</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">new_capacity</code>. </p></td>
2109 </tr>
2110 <tr>
2111 <td><p><span class="term">Throws:</span></p></td>
2112 <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>
2113 </tr>
2114 </tbody>
2115 </table></div>
2116 </li>
2117 <li class="listitem">
2118 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624957840-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2119
2120
2121 </p>
2122 <p><b>Exception Safety.&#160;</b>Basic. </p>
2123 <p>
2124 </p>
2125 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new size is greater than the current capacity. Invalidates iterators pointing to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate any iterator. </p>
2126 <p>
2127 </p>
2128 <p><b>Complexity.&#160;</b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2129 <p>
2130 </p>
2131 <p><span class="bold"><strong>See Also:</strong></span></p>
2132 <p><code class="computeroutput">rresize(size_type, const_reference)</code>, <code class="computeroutput">set_capacity(capacity_type)</code> </p>
2133 <p>
2134 </p>
2135 <p>
2136 </p>
2137 <div class="variablelist"><table border="0" class="variablelist compact">
2138 <colgroup>
2139 <col align="left" valign="top">
2140 <col>
2141 </colgroup>
2142 <tbody>
2143 <tr>
2144 <td><p><span class="term">Parameters:</span></p></td>
2145 <td><div class="variablelist"><table border="0" class="variablelist compact">
2146 <colgroup>
2147 <col align="left" valign="top">
2148 <col>
2149 </colgroup>
2150 <tbody>
2151 <tr>
2152 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2153 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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>
2154 </tr>
2155 <tr>
2156 <td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td>
2157 <td><p>The new size. </p></td>
2158 </tr>
2159 </tbody>
2160 </table></div></td>
2161 </tr>
2162 <tr>
2163 <td><p><span class="term">Postconditions:</span></p></td>
2164 <td><p><code class="computeroutput">size() == new_size &amp;&amp; capacity() &gt;= new_size</code><br>
2165 <br>
2166  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_buffer.html" title="Class template circular_buffer">circular_buffer</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>
2167  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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.) </p></td>
2168 </tr>
2169 <tr>
2170 <td><p><span class="term">Throws:</span></p></td>
2171 <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>
2172 </tr>
2173 </tbody>
2174 </table></div>
2175 </li>
2176 <li class="listitem">
2177 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624935600-bb"></a><span class="identifier">rset_capacity</span><span class="special">(</span><span class="identifier">capacity_type</span> new_capacity<span class="special">)</span><span class="special">;</span></pre>Change the capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2178
2179
2180
2181 </p>
2182 <p><b>Exception Safety.&#160;</b>Strong. </p>
2183 <p>
2184 </p>
2185 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new capacity is different from the original. </p>
2186 <p>
2187 </p>
2188 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[size(), new_capacity]</code>). </p>
2189 <p>
2190 </p>
2191 <p><span class="bold"><strong>See Also:</strong></span></p>
2192 <p><code class="computeroutput">set_capacity(capacity_type)</code>, <code class="computeroutput">rresize(size_type, const_reference)</code> </p>
2193 <p>
2194 </p>
2195 <p>
2196 </p>
2197 <div class="variablelist"><table border="0" class="variablelist compact">
2198 <colgroup>
2199 <col align="left" valign="top">
2200 <col>
2201 </colgroup>
2202 <tbody>
2203 <tr>
2204 <td><p><span class="term">Parameters:</span></p></td>
2205 <td><div class="variablelist"><table border="0" class="variablelist compact">
2206 <colgroup>
2207 <col align="left" valign="top">
2208 <col>
2209 </colgroup>
2210 <tbody><tr>
2211 <td><p><span class="term"><code class="computeroutput">new_capacity</code></span></p></td>
2212 <td><p>The new capacity. </p></td>
2213 </tr></tbody>
2214 </table></div></td>
2215 </tr>
2216 <tr>
2217 <td><p><span class="term">Requires:</span></p></td>
2218 <td><p>If <code class="computeroutput">T</code> is a move only type, then compiler shall support <code class="computeroutput">noexcept</code> modifiers and move constructor of <code class="computeroutput">T</code> must be marked with it (must not throw exceptions). </p></td>
2219 </tr>
2220 <tr>
2221 <td><p><span class="term">Postconditions:</span></p></td>
2222 <td><p><code class="computeroutput">capacity() == new_capacity &amp;&amp; size() &lt;= new_capacity</code><br>
2223 <br>
2224  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is greater than the desired new capacity then number of <code class="computeroutput">[size() - new_capacity]</code> <span class="bold"><strong>first</strong></span> elements will be removed and the new size will be equal to <code class="computeroutput">new_capacity</code>. </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="keyword">void</span> <a name="idm46495624917104-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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2235
2236
2237 </p>
2238 <p><b>Exception Safety.&#160;</b>Basic. </p>
2239 <p>
2240 </p>
2241 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>) if the new size is greater than the current capacity. Invalidates iterators pointing to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate any iterator. </p>
2242 <p>
2243 </p>
2244 <p><b>Complexity.&#160;</b>Linear (in the new size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2245 <p>
2246 </p>
2247 <p><span class="bold"><strong>See Also:</strong></span></p>
2248 <p><code class="computeroutput">resize(size_type, const_reference)</code>, <code class="computeroutput">rset_capacity(capacity_type)</code> </p>
2249 <p>
2250 </p>
2251 <p>
2252 </p>
2253 <div class="variablelist"><table border="0" class="variablelist compact">
2254 <colgroup>
2255 <col align="left" valign="top">
2256 <col>
2257 </colgroup>
2258 <tbody>
2259 <tr>
2260 <td><p><span class="term">Parameters:</span></p></td>
2261 <td><div class="variablelist"><table border="0" class="variablelist compact">
2262 <colgroup>
2263 <col align="left" valign="top">
2264 <col>
2265 </colgroup>
2266 <tbody>
2267 <tr>
2268 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2269 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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>
2270 </tr>
2271 <tr>
2272 <td><p><span class="term"><code class="computeroutput">new_size</code></span></p></td>
2273 <td><p>The new size. </p></td>
2274 </tr>
2275 </tbody>
2276 </table></div></td>
2277 </tr>
2278 <tr>
2279 <td><p><span class="term">Postconditions:</span></p></td>
2280 <td><p><code class="computeroutput">size() == new_size &amp;&amp; capacity() &gt;= new_size</code><br>
2281 <br>
2282  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_buffer.html" title="Class template circular_buffer">circular_buffer</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>
2283  If the current number of elements stored in the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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.) </p></td>
2284 </tr>
2285 <tr>
2286 <td><p><span class="term">Throws:</span></p></td>
2287 <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>
2288 </tr>
2289 </tbody>
2290 </table></div>
2291 </li>
2292 <li class="listitem">
2293 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624894864-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>.
2294
2295
2296 </p>
2297 <p><b>Exception Safety.&#160;</b>Basic. </p>
2298 <p>
2299 </p>
2300 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2301 <p>
2302 </p>
2303 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
2304 <p>
2305 </p>
2306 <p><span class="bold"><strong>See Also:</strong></span></p>
2307 <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>
2308 <p>
2309 </p>
2310 <p>
2311 </p>
2312 <div class="variablelist"><table border="0" class="variablelist compact">
2313 <colgroup>
2314 <col align="left" valign="top">
2315 <col>
2316 </colgroup>
2317 <tbody>
2318 <tr>
2319 <td><p><span class="term">Parameters:</span></p></td>
2320 <td><div class="variablelist"><table border="0" class="variablelist compact">
2321 <colgroup>
2322 <col align="left" valign="top">
2323 <col>
2324 </colgroup>
2325 <tbody>
2326 <tr>
2327 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2328 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
2329 </tr>
2330 <tr>
2331 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
2332 <td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
2333 </tr>
2334 </tbody>
2335 </table></div></td>
2336 </tr>
2337 <tr>
2338 <td><p><span class="term">Postconditions:</span></p></td>
2339 <td><p><code class="computeroutput">capacity() == n &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1] == item</code> </p></td>
2340 </tr>
2341 <tr>
2342 <td><p><span class="term">Throws:</span></p></td>
2343 <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>
2344 </tr>
2345 </tbody>
2346 </table></div>
2347 </li>
2348 <li class="listitem">
2349 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624875856-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with <code class="computeroutput">n</code> copies of the <code class="computeroutput">item</code>.
2350
2351
2352
2353 </p>
2354 <p><b>Exception Safety.&#160;</b>Basic. </p>
2355 <p>
2356 </p>
2357 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2358 <p>
2359 </p>
2360 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">n</code>). </p>
2361 <p>
2362 </p>
2363 <p><span class="bold"><strong>See Also:</strong></span></p>
2364 <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>
2365 <p>
2366 </p>
2367 <p>
2368 </p>
2369 <div class="variablelist"><table border="0" class="variablelist compact">
2370 <colgroup>
2371 <col align="left" valign="top">
2372 <col>
2373 </colgroup>
2374 <tbody>
2375 <tr>
2376 <td><p><span class="term">Parameters:</span></p></td>
2377 <td><div class="variablelist"><table border="0" class="variablelist compact">
2378 <colgroup>
2379 <col align="left" valign="top">
2380 <col>
2381 </colgroup>
2382 <tbody>
2383 <tr>
2384 <td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td>
2385 <td><p>The new capacity. </p></td>
2386 </tr>
2387 <tr>
2388 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2389 <td><p>The element the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
2390 </tr>
2391 <tr>
2392 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
2393 <td><p>The number of elements the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be filled with. </p></td>
2394 </tr>
2395 </tbody>
2396 </table></div></td>
2397 </tr>
2398 <tr>
2399 <td><p><span class="term">Requires:</span></p></td>
2400 <td><p><code class="computeroutput">capacity &gt;= n</code> </p></td>
2401 </tr>
2402 <tr>
2403 <td><p><span class="term">Postconditions:</span></p></td>
2404 <td><p><code class="computeroutput">capacity() == buffer_capacity &amp;&amp; size() == n &amp;&amp; (*this)[0] == item &amp;&amp; (*this)[1] == item &amp;&amp; ... &amp;&amp; (*this) [n - 1] == item </code> </p></td>
2405 </tr>
2406 <tr>
2407 <td><p><span class="term">Throws:</span></p></td>
2408 <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>
2409 </tr>
2410 </tbody>
2411 </table></div>
2412 </li>
2413 <li class="listitem">
2414 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
2415   <span class="keyword">void</span> <a name="idm46495624853968-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>The content of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with copies of elements from the specified range.
2416
2417
2418
2419 </p>
2420 <p><b>Exception Safety.&#160;</b>Basic. </p>
2421 <p>
2422 </p>
2423 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2424 <p>
2425 </p>
2426 <p><b>Complexity.&#160;</b>Linear (in the <code class="computeroutput">std::distance(first, last)</code>). </p>
2427 <p>
2428 </p>
2429 <p><span class="bold"><strong>See Also:</strong></span></p>
2430 <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>
2431 <p>
2432 </p>
2433 <p>
2434 </p>
2435 <div class="variablelist"><table border="0" class="variablelist compact">
2436 <colgroup>
2437 <col align="left" valign="top">
2438 <col>
2439 </colgroup>
2440 <tbody>
2441 <tr>
2442 <td><p><span class="term">Parameters:</span></p></td>
2443 <td><div class="variablelist"><table border="0" class="variablelist compact">
2444 <colgroup>
2445 <col align="left" valign="top">
2446 <col>
2447 </colgroup>
2448 <tbody>
2449 <tr>
2450 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2451 <td><p>The beginning of the range to be copied. </p></td>
2452 </tr>
2453 <tr>
2454 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2455 <td><p>The end of the range to be copied. </p></td>
2456 </tr>
2457 </tbody>
2458 </table></div></td>
2459 </tr>
2460 <tr>
2461 <td><p><span class="term">Requires:</span></p></td>
2462 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
2463  <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>
2464 </tr>
2465 <tr>
2466 <td><p><span class="term">Postconditions:</span></p></td>
2467 <td><p><code class="computeroutput">capacity() == std::distance(first, last) &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> </p></td>
2468 </tr>
2469 <tr>
2470 <td><p><span class="term">Throws:</span></p></td>
2471 <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>
2472 </tr>
2473 </tbody>
2474 </table></div>
2475 </li>
2476 <li class="listitem">
2477 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
2478   <span class="keyword">void</span> <a name="idm46495624833984-bb"></a><span class="identifier">assign</span><span class="special">(</span><span class="identifier">capacity_type</span> buffer_capacity<span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span>
2479               <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>Assign a copy of the range into the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> specifying the capacity. <p>The capacity of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> will be removed and replaced with copies of elements from the specified range.
2480
2481
2482
2483 </p>
2484 <p><b>Exception Safety.&#160;</b>Basic. </p>
2485 <p>
2486 </p>
2487 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
2488 <p>
2489 </p>
2490 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(first, last)</code>; in <code class="computeroutput">min[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>
2491 <p>
2492 </p>
2493 <p><span class="bold"><strong>See Also:</strong></span></p>
2494 <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>
2495 <p>
2496 </p>
2497 <p>
2498 </p>
2499 <div class="variablelist"><table border="0" class="variablelist compact">
2500 <colgroup>
2501 <col align="left" valign="top">
2502 <col>
2503 </colgroup>
2504 <tbody>
2505 <tr>
2506 <td><p><span class="term">Parameters:</span></p></td>
2507 <td><div class="variablelist"><table border="0" class="variablelist compact">
2508 <colgroup>
2509 <col align="left" valign="top">
2510 <col>
2511 </colgroup>
2512 <tbody>
2513 <tr>
2514 <td><p><span class="term"><code class="computeroutput">buffer_capacity</code></span></p></td>
2515 <td><p>The new capacity. </p></td>
2516 </tr>
2517 <tr>
2518 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
2519 <td><p>The beginning of the range to be copied. </p></td>
2520 </tr>
2521 <tr>
2522 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
2523 <td><p>The end of the range to be copied. </p></td>
2524 </tr>
2525 </tbody>
2526 </table></div></td>
2527 </tr>
2528 <tr>
2529 <td><p><span class="term">Requires:</span></p></td>
2530 <td><p>Valid range <code class="computeroutput">[first, last)</code>.<br>
2531  <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>
2532 </tr>
2533 <tr>
2534 <td><p><span class="term">Postconditions:</span></p></td>
2535 <td><p><code class="computeroutput">capacity() == buffer_capacity &amp;&amp; size() &lt;= std::distance(first, last) &amp;&amp; (*this)[0]== *(last - buffer_capacity) &amp;&amp; (*this)[1] == *(last - buffer_capacity + 1) &amp;&amp; ... &amp;&amp; (*this)[buffer_capacity - 1] == *(last - 1)</code><br>
2536 <br>
2537  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">buffer_capacity</code> then only elements from the range <code class="computeroutput">[last - buffer_capacity, last)</code> will be copied. </p></td>
2538 </tr>
2539 <tr>
2540 <td><p><span class="term">Throws:</span></p></td>
2541 <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>
2542 </tr>
2543 </tbody>
2544 </table></div>
2545 </li>
2546 <li class="listitem">
2547 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624808464-bb"></a><span class="identifier">swap</span><span class="special">(</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">&amp;</span> cb<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Swap the contents of two <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>s. <p>
2548
2549
2550 </p>
2551 <p><b>Exception Safety.&#160;</b>No-throw. </p>
2552 <p>
2553 </p>
2554 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators of both <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>s. (On the other hand the iterators still point to the same elements but within another container. If you want to rely on this feature you have to turn the <a href="../#debug" target="_top">Debug Support</a> off otherwise an assertion will report an error if such invalidated iterator is used.) </p>
2555 <p>
2556 </p>
2557 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2558 <p>
2559 </p>
2560 <p><span class="bold"><strong>See Also:</strong></span></p>
2561 <p><code class="computeroutput">swap(circular_buffer&lt;T, Alloc&gt;&amp;, circular_buffer&lt;T, Alloc&gt;&amp;)</code> </p>
2562 <p>
2563 </p>
2564 <p>
2565 </p>
2566 <div class="variablelist"><table border="0" class="variablelist compact">
2567 <colgroup>
2568 <col align="left" valign="top">
2569 <col>
2570 </colgroup>
2571 <tbody>
2572 <tr>
2573 <td><p><span class="term">Parameters:</span></p></td>
2574 <td><div class="variablelist"><table border="0" class="variablelist compact">
2575 <colgroup>
2576 <col align="left" valign="top">
2577 <col>
2578 </colgroup>
2579 <tbody><tr>
2580 <td><p><span class="term"><code class="computeroutput">cb</code></span></p></td>
2581 <td><p>The <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> whose content will be swapped. </p></td>
2582 </tr></tbody>
2583 </table></div></td>
2584 </tr>
2585 <tr>
2586 <td><p><span class="term">Postconditions:</span></p></td>
2587 <td><p><code class="computeroutput">this</code> contains elements of <code class="computeroutput">cb</code> and vice versa; the capacity of <code class="computeroutput">this</code> equals to the capacity of <code class="computeroutput">cb</code> and vice versa. </p></td>
2588 </tr>
2589 <tr>
2590 <td><p><span class="term">Throws:</span></p></td>
2591 <td>Nothing. </td>
2592 </tr>
2593 </tbody>
2594 </table></div>
2595 </li>
2596 <li class="listitem">
2597 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624793200-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2598
2599
2600 </p>
2601 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2602 <p>
2603 </p>
2604 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2605 <p>
2606 </p>
2607 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2608 <p>
2609 </p>
2610 <p><span class="bold"><strong>See Also:</strong></span></p>
2611 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2612 <p>
2613 </p>
2614 <p>
2615 </p>
2616 <div class="variablelist"><table border="0" class="variablelist compact">
2617 <colgroup>
2618 <col align="left" valign="top">
2619 <col>
2620 </colgroup>
2621 <tbody>
2622 <tr>
2623 <td><p><span class="term">Parameters:</span></p></td>
2624 <td><div class="variablelist"><table border="0" class="variablelist compact">
2625 <colgroup>
2626 <col align="left" valign="top">
2627 <col>
2628 </colgroup>
2629 <tbody><tr>
2630 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2631 <td><p>The element to be inserted. </p></td>
2632 </tr></tbody>
2633 </table></div></td>
2634 </tr>
2635 <tr>
2636 <td><p><span class="term">Postconditions:</span></p></td>
2637 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
2638  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2639 </tr>
2640 <tr>
2641 <td><p><span class="term">Throws:</span></p></td>
2642 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
2643 </tr>
2644 </tbody>
2645 </table></div>
2646 </li>
2647 <li class="listitem">
2648 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624778080-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> using rvalue references or rvalues references emulation. <p>
2649
2650
2651 </p>
2652 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2653 <p>
2654 </p>
2655 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2656 <p>
2657 </p>
2658 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2659 <p>
2660 </p>
2661 <p><span class="bold"><strong>See Also:</strong></span></p>
2662 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2663 <p>
2664 </p>
2665 <p>
2666 </p>
2667 <div class="variablelist"><table border="0" class="variablelist compact">
2668 <colgroup>
2669 <col align="left" valign="top">
2670 <col>
2671 </colgroup>
2672 <tbody>
2673 <tr>
2674 <td><p><span class="term">Parameters:</span></p></td>
2675 <td><div class="variablelist"><table border="0" class="variablelist compact">
2676 <colgroup>
2677 <col align="left" valign="top">
2678 <col>
2679 </colgroup>
2680 <tbody><tr>
2681 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2682 <td><p>The element to be inserted. </p></td>
2683 </tr></tbody>
2684 </table></div></td>
2685 </tr>
2686 <tr>
2687 <td><p><span class="term">Postconditions:</span></p></td>
2688 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
2689  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2690 </tr>
2691 <tr>
2692 <td><p><span class="term">Throws:</span></p></td>
2693 <td>Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. </td>
2694 </tr>
2695 </tbody>
2696 </table></div>
2697 </li>
2698 <li class="listitem">
2699 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624762928-bb"></a><span class="identifier">push_back</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new default-constructed element at the end of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2700
2701 </p>
2702 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2703 <p>
2704 </p>
2705 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2706 <p>
2707 </p>
2708 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2709 <p>
2710 </p>
2711 <p><span class="bold"><strong>See Also:</strong></span></p>
2712 <p><code class="computeroutput">push_front(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2713 <p>
2714 </p>
2715 <p>
2716 </p>
2717 <div class="variablelist"><table border="0" class="variablelist compact">
2718 <colgroup>
2719 <col align="left" valign="top">
2720 <col>
2721 </colgroup>
2722 <tbody>
2723 <tr>
2724 <td><p><span class="term">Postconditions:</span></p></td>
2725 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">back() == item</code><br>
2726  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2727 </tr>
2728 <tr>
2729 <td><p><span class="term">Throws:</span></p></td>
2730 <td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. </td>
2731 </tr>
2732 </tbody>
2733 </table></div>
2734 </li>
2735 <li class="listitem">
2736 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624748464-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2737
2738
2739 </p>
2740 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2741 <p>
2742 </p>
2743 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2744 <p>
2745 </p>
2746 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2747 <p>
2748 </p>
2749 <p><span class="bold"><strong>See Also:</strong></span></p>
2750 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2751 <p>
2752 </p>
2753 <p>
2754 </p>
2755 <div class="variablelist"><table border="0" class="variablelist compact">
2756 <colgroup>
2757 <col align="left" valign="top">
2758 <col>
2759 </colgroup>
2760 <tbody>
2761 <tr>
2762 <td><p><span class="term">Parameters:</span></p></td>
2763 <td><div class="variablelist"><table border="0" class="variablelist compact">
2764 <colgroup>
2765 <col align="left" valign="top">
2766 <col>
2767 </colgroup>
2768 <tbody><tr>
2769 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2770 <td><p>The element to be inserted. </p></td>
2771 </tr></tbody>
2772 </table></div></td>
2773 </tr>
2774 <tr>
2775 <td><p><span class="term">Postconditions:</span></p></td>
2776 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
2777  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2778 </tr>
2779 <tr>
2780 <td><p><span class="term">Throws:</span></p></td>
2781 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. </td>
2782 </tr>
2783 </tbody>
2784 </table></div>
2785 </li>
2786 <li class="listitem">
2787 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624733328-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> using rvalue references or rvalues references emulation. <p>
2788
2789
2790 </p>
2791 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2792 <p>
2793 </p>
2794 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2795 <p>
2796 </p>
2797 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2798 <p>
2799 </p>
2800 <p><span class="bold"><strong>See Also:</strong></span></p>
2801 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2802 <p>
2803 </p>
2804 <p>
2805 </p>
2806 <div class="variablelist"><table border="0" class="variablelist compact">
2807 <colgroup>
2808 <col align="left" valign="top">
2809 <col>
2810 </colgroup>
2811 <tbody>
2812 <tr>
2813 <td><p><span class="term">Parameters:</span></p></td>
2814 <td><div class="variablelist"><table border="0" class="variablelist compact">
2815 <colgroup>
2816 <col align="left" valign="top">
2817 <col>
2818 </colgroup>
2819 <tbody><tr>
2820 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2821 <td><p>The element to be inserted. </p></td>
2822 </tr></tbody>
2823 </table></div></td>
2824 </tr>
2825 <tr>
2826 <td><p><span class="term">Postconditions:</span></p></td>
2827 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
2828  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2829 </tr>
2830 <tr>
2831 <td><p><span class="term">Throws:</span></p></td>
2832 <td>Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. </td>
2833 </tr>
2834 </tbody>
2835 </table></div>
2836 </li>
2837 <li class="listitem">
2838 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624718160-bb"></a><span class="identifier">push_front</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Insert a new default-constructed element at the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2839
2840 </p>
2841 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2842 <p>
2843 </p>
2844 <p><b>Iterator Invalidation.&#160;</b>Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. </p>
2845 <p>
2846 </p>
2847 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2848 <p>
2849 </p>
2850 <p><span class="bold"><strong>See Also:</strong></span></p>
2851 <p><code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">pop_back()</code>, <code class="computeroutput">pop_front()</code> </p>
2852 <p>
2853 </p>
2854 <p>
2855 </p>
2856 <div class="variablelist"><table border="0" class="variablelist compact">
2857 <colgroup>
2858 <col align="left" valign="top">
2859 <col>
2860 </colgroup>
2861 <tbody>
2862 <tr>
2863 <td><p><span class="term">Postconditions:</span></p></td>
2864 <td><p>if <code class="computeroutput">capacity() &gt; 0</code> then <code class="computeroutput">front() == item</code><br>
2865  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be removed. If the capacity is <code class="computeroutput">0</code>, nothing will be inserted. </p></td>
2866 </tr>
2867 <tr>
2868 <td><p><span class="term">Throws:</span></p></td>
2869 <td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. </td>
2870 </tr>
2871 </tbody>
2872 </table></div>
2873 </li>
2874 <li class="listitem">
2875 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624703696-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2876
2877
2878 </p>
2879 <p><b>Exception Safety.&#160;</b>No-throw. </p>
2880 <p>
2881 </p>
2882 <p><b>Iterator Invalidation.&#160;</b>Invalidates only iterators pointing to the removed element. </p>
2883 <p>
2884 </p>
2885 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2886 <p>
2887 </p>
2888 <p><span class="bold"><strong>See Also:</strong></span></p>
2889 <p><code class="computeroutput">pop_front()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p>
2890 <p>
2891 </p>
2892 <p>
2893 </p>
2894 <div class="variablelist"><table border="0" class="variablelist compact">
2895 <colgroup>
2896 <col align="left" valign="top">
2897 <col>
2898 </colgroup>
2899 <tbody>
2900 <tr>
2901 <td><p><span class="term">Requires:</span></p></td>
2902 <td><p><code class="computeroutput">!empty()</code> </p></td>
2903 </tr>
2904 <tr>
2905 <td><p><span class="term">Postconditions:</span></p></td>
2906 <td><p>The last element is removed from the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
2907 </tr>
2908 <tr>
2909 <td><p><span class="term">Throws:</span></p></td>
2910 <td>Nothing. </td>
2911 </tr>
2912 </tbody>
2913 </table></div>
2914 </li>
2915 <li class="listitem">
2916 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624691776-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 <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
2917
2918
2919 </p>
2920 <p><b>Exception Safety.&#160;</b>No-throw. </p>
2921 <p>
2922 </p>
2923 <p><b>Iterator Invalidation.&#160;</b>Invalidates only iterators pointing to the removed element. </p>
2924 <p>
2925 </p>
2926 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>). </p>
2927 <p>
2928 </p>
2929 <p><span class="bold"><strong>See Also:</strong></span></p>
2930 <p><code class="computeroutput">pop_back()</code>, <code class="computeroutput">push_back(const_reference)</code>, <code class="computeroutput">push_front(const_reference)</code> </p>
2931 <p>
2932 </p>
2933 <p>
2934 </p>
2935 <div class="variablelist"><table border="0" class="variablelist compact">
2936 <colgroup>
2937 <col align="left" valign="top">
2938 <col>
2939 </colgroup>
2940 <tbody>
2941 <tr>
2942 <td><p><span class="term">Requires:</span></p></td>
2943 <td><p><code class="computeroutput">!empty()</code> </p></td>
2944 </tr>
2945 <tr>
2946 <td><p><span class="term">Postconditions:</span></p></td>
2947 <td><p>The first element is removed from the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>. </p></td>
2948 </tr>
2949 <tr>
2950 <td><p><span class="term">Throws:</span></p></td>
2951 <td>Nothing. </td>
2952 </tr>
2953 </tbody>
2954 </table></div>
2955 </li>
2956 <li class="listitem">
2957 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624679856-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>
2958
2959
2960
2961
2962 </p>
2963 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
2964 <p>
2965 </p>
2966 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p>
2967 <p>
2968 </p>
2969 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p>
2970 <p>
2971 </p>
2972 <p><span class="bold"><strong>See Also:</strong></span></p>
2973 <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>
2974 <p>
2975 </p>
2976 <p>
2977 </p>
2978 <div class="variablelist"><table border="0" class="variablelist compact">
2979 <colgroup>
2980 <col align="left" valign="top">
2981 <col>
2982 </colgroup>
2983 <tbody>
2984 <tr>
2985 <td><p><span class="term">Parameters:</span></p></td>
2986 <td><div class="variablelist"><table border="0" class="variablelist compact">
2987 <colgroup>
2988 <col align="left" valign="top">
2989 <col>
2990 </colgroup>
2991 <tbody>
2992 <tr>
2993 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
2994 <td><p>The element to be inserted. </p></td>
2995 </tr>
2996 <tr>
2997 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
2998 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
2999 </tr>
3000 </tbody>
3001 </table></div></td>
3002 </tr>
3003 <tr>
3004 <td><p><span class="term">Requires:</span></p></td>
3005 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3006 </tr>
3007 <tr>
3008 <td><p><span class="term">Postconditions:</span></p></td>
3009 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
3010  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3011 </tr>
3012 <tr>
3013 <td><p><span class="term">Returns:</span></p></td>
3014 <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>
3015 </tr>
3016 <tr>
3017 <td><p><span class="term">Throws:</span></p></td>
3018 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>.</td>
3019 </tr>
3020 </tbody>
3021 </table></div>
3022 </li>
3023 <li class="listitem">
3024 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624655488-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>
3025
3026
3027
3028
3029 </p>
3030 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3031 <p>
3032 </p>
3033 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p>
3034 <p>
3035 </p>
3036 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p>
3037 <p>
3038 </p>
3039 <p><span class="bold"><strong>See Also:</strong></span></p>
3040 <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>
3041 <p>
3042 </p>
3043 <p>
3044 </p>
3045 <div class="variablelist"><table border="0" class="variablelist compact">
3046 <colgroup>
3047 <col align="left" valign="top">
3048 <col>
3049 </colgroup>
3050 <tbody>
3051 <tr>
3052 <td><p><span class="term">Parameters:</span></p></td>
3053 <td><div class="variablelist"><table border="0" class="variablelist compact">
3054 <colgroup>
3055 <col align="left" valign="top">
3056 <col>
3057 </colgroup>
3058 <tbody>
3059 <tr>
3060 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
3061 <td><p>The element to be inserted. </p></td>
3062 </tr>
3063 <tr>
3064 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3065 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
3066 </tr>
3067 </tbody>
3068 </table></div></td>
3069 </tr>
3070 <tr>
3071 <td><p><span class="term">Requires:</span></p></td>
3072 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3073 </tr>
3074 <tr>
3075 <td><p><span class="term">Postconditions:</span></p></td>
3076 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
3077  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3078 </tr>
3079 <tr>
3080 <td><p><span class="term">Returns:</span></p></td>
3081 <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>
3082 </tr>
3083 <tr>
3084 <td><p><span class="term">Throws:</span></p></td>
3085 <td>Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3086 </tr>
3087 </tbody>
3088 </table></div>
3089 </li>
3090 <li class="listitem">
3091 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624631136-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 a default-constructed element at the specified position. <p>
3092
3093
3094
3095
3096 </p>
3097 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3098 <p>
3099 </p>
3100 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten element. </p>
3101 <p>
3102 </p>
3103 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p>
3104 <p>
3105 </p>
3106 <p><span class="bold"><strong>See Also:</strong></span></p>
3107 <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>
3108 <p>
3109 </p>
3110 <p>
3111 </p>
3112 <div class="variablelist"><table border="0" class="variablelist compact">
3113 <colgroup>
3114 <col align="left" valign="top">
3115 <col>
3116 </colgroup>
3117 <tbody>
3118 <tr>
3119 <td><p><span class="term">Parameters:</span></p></td>
3120 <td><div class="variablelist"><table border="0" class="variablelist compact">
3121 <colgroup>
3122 <col align="left" valign="top">
3123 <col>
3124 </colgroup>
3125 <tbody><tr>
3126 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3127 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code> will be inserted. </p></td>
3128 </tr></tbody>
3129 </table></div></td>
3130 </tr>
3131 <tr>
3132 <td><p><span class="term">Requires:</span></p></td>
3133 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3134 </tr>
3135 <tr>
3136 <td><p><span class="term">Postconditions:</span></p></td>
3137 <td><p>The <code class="computeroutput">item</code> will be inserted at the position <code class="computeroutput">pos</code>.<br>
3138  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the first element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3139 </tr>
3140 <tr>
3141 <td><p><span class="term">Returns:</span></p></td>
3142 <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>
3143 </tr>
3144 <tr>
3145 <td><p><span class="term">Throws:</span></p></td>
3146 <td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3147 </tr>
3148 </tbody>
3149 </table></div>
3150 </li>
3151 <li class="listitem">
3152 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624607440-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>
3153
3154
3155
3156 </p>
3157 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3158 <p>
3159 </p>
3160 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten elements. </p>
3161 <p>
3162 </p>
3163 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[capacity(), std::distance(pos, end()) + n]</code>). </p>
3164 <p>
3165 </p>
3166 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
3167 <br>
3168  <code class="computeroutput">|1|2|3|4| | |</code><br>
3169  <code class="computeroutput">p ___^</code><br>
3170 <br>
3171 After inserting 5 elements at the position <code class="computeroutput">p</code>:<br>
3172 <br>
3173  <code class="computeroutput">insert(p, (size_t)5, 0);</code><br>
3174 <br>
3175 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>
3176 <br>
3177 <code class="computeroutput">|0|0|0|0|3|4|</code><br>
3178  <br>
3179 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>
3180 <p>
3181 </p>
3182 <p><span class="bold"><strong>See Also:</strong></span></p>
3183 <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>
3184 <p>
3185 </p>
3186 <p>
3187 </p>
3188 <div class="variablelist"><table border="0" class="variablelist compact">
3189 <colgroup>
3190 <col align="left" valign="top">
3191 <col>
3192 </colgroup>
3193 <tbody>
3194 <tr>
3195 <td><p><span class="term">Parameters:</span></p></td>
3196 <td><div class="variablelist"><table border="0" class="variablelist compact">
3197 <colgroup>
3198 <col align="left" valign="top">
3199 <col>
3200 </colgroup>
3201 <tbody>
3202 <tr>
3203 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
3204 <td><p>The element whose copies will be inserted. </p></td>
3205 </tr>
3206 <tr>
3207 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
3208 <td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td>
3209 </tr>
3210 <tr>
3211 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3212 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td>
3213 </tr>
3214 </tbody>
3215 </table></div></td>
3216 </tr>
3217 <tr>
3218 <td><p><span class="term">Requires:</span></p></td>
3219 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3220 </tr>
3221 <tr>
3222 <td><p><span class="term">Postconditions:</span></p></td>
3223 <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>
3224 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br>
3225 (See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td>
3226 </tr>
3227 <tr>
3228 <td><p><span class="term">Throws:</span></p></td>
3229 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3230 </tr>
3231 </tbody>
3232 </table></div>
3233 </li>
3234 <li class="listitem">
3235 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
3236   <span class="keyword">void</span> <a name="idm46495624575088-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>
3237
3238
3239
3240 </p>
3241 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3242 <p>
3243 </p>
3244 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements at the insertion point (including <code class="computeroutput">pos</code>) and iterators behind the insertion point (towards the end; except iterators equal to <code class="computeroutput">end()</code>). It also invalidates iterators pointing to the overwritten elements. </p>
3245 <p>
3246 </p>
3247 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">[std::distance(pos, end()) + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity(), std::distance(pos, end()) + 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>
3248 <p>
3249 </p>
3250 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
3251 <br>
3252  <code class="computeroutput">|1|2|3|4| | |</code><br>
3253  <code class="computeroutput">p ___^</code><br>
3254 <br>
3255 After inserting a range of elements at the position <code class="computeroutput">p</code>:<br>
3256 <br>
3257  <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br>
3258 <code class="computeroutput">insert(p, array, array + 5);</code><br>
3259 <br>
3260  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>
3261 <br>
3262 <code class="computeroutput">|6|7|8|9|3|4|</code><br>
3263 <br>
3264 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>
3265 <p>
3266 </p>
3267 <p><span class="bold"><strong>See Also:</strong></span></p>
3268 <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>
3269 <p>
3270 </p>
3271 <p>
3272 </p>
3273 <div class="variablelist"><table border="0" class="variablelist compact">
3274 <colgroup>
3275 <col align="left" valign="top">
3276 <col>
3277 </colgroup>
3278 <tbody>
3279 <tr>
3280 <td><p><span class="term">Parameters:</span></p></td>
3281 <td><div class="variablelist"><table border="0" class="variablelist compact">
3282 <colgroup>
3283 <col align="left" valign="top">
3284 <col>
3285 </colgroup>
3286 <tbody>
3287 <tr>
3288 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
3289 <td><p>The beginning of the range to be inserted. </p></td>
3290 </tr>
3291 <tr>
3292 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
3293 <td><p>The end of the range to be inserted. </p></td>
3294 </tr>
3295 <tr>
3296 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3297 <td><p>An iterator specifying the position where the range will be inserted. </p></td>
3298 </tr>
3299 </tbody>
3300 </table></div></td>
3301 </tr>
3302 <tr>
3303 <td><p><span class="term">Requires:</span></p></td>
3304 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end.<br>
3305  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>
3306 </tr>
3307 <tr>
3308 <td><p><span class="term">Postconditions:</span></p></td>
3309 <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>
3310 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br>
3311 (See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td>
3312 </tr>
3313 <tr>
3314 <td><p><span class="term">Throws:</span></p></td>
3315 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. </td>
3316 </tr>
3317 </tbody>
3318 </table></div>
3319 </li>
3320 <li class="listitem">
3321 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624534720-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>
3322
3323
3324
3325
3326 </p>
3327 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3328 <p>
3329 </p>
3330 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p>
3331 <p>
3332 </p>
3333 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p>
3334 <p>
3335 </p>
3336 <p><span class="bold"><strong>See Also:</strong></span></p>
3337 <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>
3338 <p>
3339 </p>
3340 <p>
3341 </p>
3342 <div class="variablelist"><table border="0" class="variablelist compact">
3343 <colgroup>
3344 <col align="left" valign="top">
3345 <col>
3346 </colgroup>
3347 <tbody>
3348 <tr>
3349 <td><p><span class="term">Parameters:</span></p></td>
3350 <td><div class="variablelist"><table border="0" class="variablelist compact">
3351 <colgroup>
3352 <col align="left" valign="top">
3353 <col>
3354 </colgroup>
3355 <tbody>
3356 <tr>
3357 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
3358 <td><p>The element to be inserted. </p></td>
3359 </tr>
3360 <tr>
3361 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3362 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
3363 </tr>
3364 </tbody>
3365 </table></div></td>
3366 </tr>
3367 <tr>
3368 <td><p><span class="term">Requires:</span></p></td>
3369 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3370 </tr>
3371 <tr>
3372 <td><p><span class="term">Postconditions:</span></p></td>
3373 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
3374  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3375 </tr>
3376 <tr>
3377 <td><p><span class="term">Returns:</span></p></td>
3378 <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>
3379 </tr>
3380 <tr>
3381 <td><p><span class="term">Throws:</span></p></td>
3382 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3383 </tr>
3384 </tbody>
3385 </table></div>
3386 </li>
3387 <li class="listitem">
3388 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624510848-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>
3389
3390
3391
3392
3393 </p>
3394 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3395 <p>
3396 </p>
3397 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p>
3398 <p>
3399 </p>
3400 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p>
3401 <p>
3402 </p>
3403 <p><span class="bold"><strong>See Also:</strong></span></p>
3404 <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>
3405 <p>
3406 </p>
3407 <p>
3408 </p>
3409 <div class="variablelist"><table border="0" class="variablelist compact">
3410 <colgroup>
3411 <col align="left" valign="top">
3412 <col>
3413 </colgroup>
3414 <tbody>
3415 <tr>
3416 <td><p><span class="term">Parameters:</span></p></td>
3417 <td><div class="variablelist"><table border="0" class="variablelist compact">
3418 <colgroup>
3419 <col align="left" valign="top">
3420 <col>
3421 </colgroup>
3422 <tbody>
3423 <tr>
3424 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
3425 <td><p>The element to be inserted. </p></td>
3426 </tr>
3427 <tr>
3428 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3429 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
3430 </tr>
3431 </tbody>
3432 </table></div></td>
3433 </tr>
3434 <tr>
3435 <td><p><span class="term">Requires:</span></p></td>
3436 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3437 </tr>
3438 <tr>
3439 <td><p><span class="term">Postconditions:</span></p></td>
3440 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
3441  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3442 </tr>
3443 <tr>
3444 <td><p><span class="term">Returns:</span></p></td>
3445 <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>
3446 </tr>
3447 <tr>
3448 <td><p><span class="term">Throws:</span></p></td>
3449 <td>Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3450 </tr>
3451 </tbody>
3452 </table></div>
3453 </li>
3454 <li class="listitem">
3455 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624486992-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>
3456
3457
3458
3459
3460 </p>
3461 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3462 <p>
3463 </p>
3464 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten element. </p>
3465 <p>
3466 </p>
3467 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p>
3468 <p>
3469 </p>
3470 <p><span class="bold"><strong>See Also:</strong></span></p>
3471 <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>
3472 <p>
3473 </p>
3474 <p>
3475 </p>
3476 <div class="variablelist"><table border="0" class="variablelist compact">
3477 <colgroup>
3478 <col align="left" valign="top">
3479 <col>
3480 </colgroup>
3481 <tbody>
3482 <tr>
3483 <td><p><span class="term">Parameters:</span></p></td>
3484 <td><div class="variablelist"><table border="0" class="variablelist compact">
3485 <colgroup>
3486 <col align="left" valign="top">
3487 <col>
3488 </colgroup>
3489 <tbody><tr>
3490 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3491 <td><p>An iterator specifying the position before which the <code class="computeroutput">item</code> will be inserted. </p></td>
3492 </tr></tbody>
3493 </table></div></td>
3494 </tr>
3495 <tr>
3496 <td><p><span class="term">Requires:</span></p></td>
3497 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3498 </tr>
3499 <tr>
3500 <td><p><span class="term">Postconditions:</span></p></td>
3501 <td><p>The <code class="computeroutput">item</code> will be inserted before the position <code class="computeroutput">pos</code>.<br>
3502  If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> is full, the last element will be overwritten. If the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</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. </p></td>
3503 </tr>
3504 <tr>
3505 <td><p><span class="term">Returns:</span></p></td>
3506 <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>
3507 </tr>
3508 <tr>
3509 <td><p><span class="term">Throws:</span></p></td>
3510 <td>Whatever <code class="computeroutput">T::T()</code> throws. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3511 </tr>
3512 </tbody>
3513 </table></div>
3514 </li>
3515 <li class="listitem">
3516 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624463808-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>
3517
3518
3519
3520 </p>
3521 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3522 <p>
3523 </p>
3524 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten elements. </p>
3525 <p>
3526 </p>
3527 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">min[capacity(), std::distance(begin(), pos) + n]</code>). </p>
3528 <p>
3529 </p>
3530 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
3531 <br>
3532  <code class="computeroutput">|1|2|3|4| | |</code><br>
3533  <code class="computeroutput">p ___^</code><br>
3534 <br>
3535 After inserting 5 elements before the position <code class="computeroutput">p</code>:<br>
3536 <br>
3537  <code class="computeroutput">rinsert(p, (size_t)5, 0);</code><br>
3538 <br>
3539 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>
3540 <br>
3541 <code class="computeroutput">|1|2|0|0|0|0|</code><br>
3542  <br>
3543 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>
3544 <p>
3545 </p>
3546 <p><span class="bold"><strong>See Also:</strong></span></p>
3547 <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>
3548 <p>
3549 </p>
3550 <p>
3551 </p>
3552 <div class="variablelist"><table border="0" class="variablelist compact">
3553 <colgroup>
3554 <col align="left" valign="top">
3555 <col>
3556 </colgroup>
3557 <tbody>
3558 <tr>
3559 <td><p><span class="term">Parameters:</span></p></td>
3560 <td><div class="variablelist"><table border="0" class="variablelist compact">
3561 <colgroup>
3562 <col align="left" valign="top">
3563 <col>
3564 </colgroup>
3565 <tbody>
3566 <tr>
3567 <td><p><span class="term"><code class="computeroutput">item</code></span></p></td>
3568 <td><p>The element whose copies will be inserted. </p></td>
3569 </tr>
3570 <tr>
3571 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
3572 <td><p>The number of <code class="computeroutput">item</code>s the to be inserted. </p></td>
3573 </tr>
3574 <tr>
3575 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3576 <td><p>An iterator specifying the position where the <code class="computeroutput">item</code>s will be inserted. </p></td>
3577 </tr>
3578 </tbody>
3579 </table></div></td>
3580 </tr>
3581 <tr>
3582 <td><p><span class="term">Requires:</span></p></td>
3583 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end. </p></td>
3584 </tr>
3585 <tr>
3586 <td><p><span class="term">Postconditions:</span></p></td>
3587 <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>
3588 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_buffer.html" title="Class template circular_buffer">circular_buffer</a></code>.<br>
3589 (See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td>
3590 </tr>
3591 <tr>
3592 <td><p><span class="term">Throws:</span></p></td>
3593 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws. <a href="../circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t" target="_top">Exceptions of move_if_noexcept(T&amp;)</a>. </td>
3594 </tr>
3595 </tbody>
3596 </table></div>
3597 </li>
3598 <li class="listitem">
3599 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
3600   <span class="keyword">void</span> <a name="idm46495624431968-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>
3601
3602
3603
3604 </p>
3605 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operations in the <span class="emphasis"><em>Throws</em></span> section do not throw anything. </p>
3606 <p>
3607 </p>
3608 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the elements before the insertion point (towards the beginning and excluding <code class="computeroutput">pos</code>). It also invalidates iterators pointing to the overwritten elements. </p>
3609 <p>
3610 </p>
3611 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">[std::distance(begin(), pos) + std::distance(first, last)]</code>; in <code class="computeroutput">min[capacity(), std::distance(begin(), pos) + 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>
3612 <p>
3613 </p>
3614 <p><b>Example.&#160;</b>Consider a <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.<br>
3615 <br>
3616  <code class="computeroutput">|1|2|3|4| | |</code><br>
3617  <code class="computeroutput">p ___^</code><br>
3618 <br>
3619 After inserting a range of elements before the position <code class="computeroutput">p</code>:<br>
3620 <br>
3621  <code class="computeroutput">int array[] = { 5, 6, 7, 8, 9 };</code><br>
3622 <code class="computeroutput">insert(p, array, array + 5);</code><br>
3623 <br>
3624  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>
3625 <br>
3626 <code class="computeroutput">|1|2|5|6|7|8|</code><br>
3627 <br>
3628 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>
3629 <p>
3630 </p>
3631 <p><span class="bold"><strong>See Also:</strong></span></p>
3632 <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>
3633 <p>
3634 </p>
3635 <p>
3636 </p>
3637 <div class="variablelist"><table border="0" class="variablelist compact">
3638 <colgroup>
3639 <col align="left" valign="top">
3640 <col>
3641 </colgroup>
3642 <tbody>
3643 <tr>
3644 <td><p><span class="term">Parameters:</span></p></td>
3645 <td><div class="variablelist"><table border="0" class="variablelist compact">
3646 <colgroup>
3647 <col align="left" valign="top">
3648 <col>
3649 </colgroup>
3650 <tbody>
3651 <tr>
3652 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
3653 <td><p>The beginning of the range to be inserted. </p></td>
3654 </tr>
3655 <tr>
3656 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
3657 <td><p>The end of the range to be inserted. </p></td>
3658 </tr>
3659 <tr>
3660 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3661 <td><p>An iterator specifying the position where the range will be inserted. </p></td>
3662 </tr>
3663 </tbody>
3664 </table></div></td>
3665 </tr>
3666 <tr>
3667 <td><p><span class="term">Requires:</span></p></td>
3668 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> or its end.<br>
3669  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>
3670 </tr>
3671 <tr>
3672 <td><p><span class="term">Postconditions:</span></p></td>
3673 <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>
3674 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>
3675 (See <span class="emphasis"><em>Example</em></span> for the explanation.) </p></td>
3676 </tr>
3677 <tr>
3678 <td><p><span class="term">Throws:</span></p></td>
3679 <td>Whatever <code class="computeroutput">T::T(const T&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::operator = (const T&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is not a move iterator. Whatever <code class="computeroutput">T::T(T&amp;&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. Whatever <code class="computeroutput">T::operator = (T&amp;&amp;)</code> throws if the <code class="computeroutput">InputIterator</code> is a move iterator. </td>
3680 </tr>
3681 </tbody>
3682 </table></div>
3683 </li>
3684 <li class="listitem">
3685 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624392048-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>
3686
3687
3688
3689
3690 </p>
3691 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3692 <p>
3693 </p>
3694 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the erased element and iterators pointing to the elements behind the erased element (towards the end; except iterators equal to <code class="computeroutput">end()</code>). </p>
3695 <p>
3696 </p>
3697 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(pos, end())</code>). </p>
3698 <p>
3699 </p>
3700 <p><span class="bold"><strong>See Also:</strong></span></p>
3701 <p><code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p>
3702 <p>
3703 </p>
3704 <p>
3705 </p>
3706 <div class="variablelist"><table border="0" class="variablelist compact">
3707 <colgroup>
3708 <col align="left" valign="top">
3709 <col>
3710 </colgroup>
3711 <tbody>
3712 <tr>
3713 <td><p><span class="term">Parameters:</span></p></td>
3714 <td><div class="variablelist"><table border="0" class="variablelist compact">
3715 <colgroup>
3716 <col align="left" valign="top">
3717 <col>
3718 </colgroup>
3719 <tbody><tr>
3720 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3721 <td><p>An iterator pointing at the element to be removed. </p></td>
3722 </tr></tbody>
3723 </table></div></td>
3724 </tr>
3725 <tr>
3726 <td><p><span class="term">Requires:</span></p></td>
3727 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> (but not an <code class="computeroutput">end()</code>). </p></td>
3728 </tr>
3729 <tr>
3730 <td><p><span class="term">Postconditions:</span></p></td>
3731 <td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td>
3732 </tr>
3733 <tr>
3734 <td><p><span class="term">Returns:</span></p></td>
3735 <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>
3736 </tr>
3737 <tr>
3738 <td><p><span class="term">Throws:</span></p></td>
3739 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
3740 </tr>
3741 </tbody>
3742 </table></div>
3743 </li>
3744 <li class="listitem">
3745 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624375712-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>
3746
3747
3748
3749
3750 </p>
3751 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3752 <p>
3753 </p>
3754 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the erased elements and iterators pointing to the elements behind the erased range (towards the end; except iterators equal to <code class="computeroutput">end()</code>). </p>
3755 <p>
3756 </p>
3757 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(first, end())</code>). </p>
3758 <p>
3759 </p>
3760 <p><span class="bold"><strong>See Also:</strong></span></p>
3761 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p>
3762 <p>
3763 </p>
3764 <p>
3765 </p>
3766 <div class="variablelist"><table border="0" class="variablelist compact">
3767 <colgroup>
3768 <col align="left" valign="top">
3769 <col>
3770 </colgroup>
3771 <tbody>
3772 <tr>
3773 <td><p><span class="term">Parameters:</span></p></td>
3774 <td><div class="variablelist"><table border="0" class="variablelist compact">
3775 <colgroup>
3776 <col align="left" valign="top">
3777 <col>
3778 </colgroup>
3779 <tbody>
3780 <tr>
3781 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
3782 <td><p>The beginning of the range to be removed. </p></td>
3783 </tr>
3784 <tr>
3785 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
3786 <td><p>The end of the range to be removed. </p></td>
3787 </tr>
3788 </tbody>
3789 </table></div></td>
3790 </tr>
3791 <tr>
3792 <td><p><span class="term">Requires:</span></p></td>
3793 <td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td>
3794 </tr>
3795 <tr>
3796 <td><p><span class="term">Postconditions:</span></p></td>
3797 <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.) </p></td>
3798 </tr>
3799 <tr>
3800 <td><p><span class="term">Returns:</span></p></td>
3801 <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>
3802 </tr>
3803 <tr>
3804 <td><p><span class="term">Throws:</span></p></td>
3805 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
3806 </tr>
3807 </tbody>
3808 </table></div>
3809 </li>
3810 <li class="listitem">
3811 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624358560-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>
3812
3813
3814
3815
3816 </p>
3817 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3818 <p>
3819 </p>
3820 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the erased element and iterators pointing to the elements in front of the erased element (towards the beginning). </p>
3821 <p>
3822 </p>
3823 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(begin(), pos)</code>). </p>
3824 <p>
3825 </p>
3826 <div class="note"><table border="0" summary="Note">
3827 <tr>
3828 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
3829 <th align="left">Note</th>
3830 </tr>
3831 <tr><td align="left" valign="top"><p>This method is symmetric to the <code class="computeroutput">erase(iterator)</code> method and is more effective than <code class="computeroutput">erase(iterator)</code> if the iterator <code class="computeroutput">pos</code> is close to the beginning of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. (See the <span class="emphasis"><em>Complexity</em></span>.) </p></td></tr>
3832 </table></div>
3833 <p>
3834 </p>
3835 <p><span class="bold"><strong>See Also:</strong></span></p>
3836 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator, iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p>
3837 <p>
3838 </p>
3839 <p>
3840 </p>
3841 <div class="variablelist"><table border="0" class="variablelist compact">
3842 <colgroup>
3843 <col align="left" valign="top">
3844 <col>
3845 </colgroup>
3846 <tbody>
3847 <tr>
3848 <td><p><span class="term">Parameters:</span></p></td>
3849 <td><div class="variablelist"><table border="0" class="variablelist compact">
3850 <colgroup>
3851 <col align="left" valign="top">
3852 <col>
3853 </colgroup>
3854 <tbody><tr>
3855 <td><p><span class="term"><code class="computeroutput">pos</code></span></p></td>
3856 <td><p>An iterator pointing at the element to be removed. </p></td>
3857 </tr></tbody>
3858 </table></div></td>
3859 </tr>
3860 <tr>
3861 <td><p><span class="term">Requires:</span></p></td>
3862 <td><p><code class="computeroutput">pos</code> is a valid iterator pointing to the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> (but not an <code class="computeroutput">end()</code>). </p></td>
3863 </tr>
3864 <tr>
3865 <td><p><span class="term">Postconditions:</span></p></td>
3866 <td><p>The element at the position <code class="computeroutput">pos</code> is removed. </p></td>
3867 </tr>
3868 <tr>
3869 <td><p><span class="term">Returns:</span></p></td>
3870 <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>
3871 </tr>
3872 <tr>
3873 <td><p><span class="term">Throws:</span></p></td>
3874 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
3875 </tr>
3876 </tbody>
3877 </table></div>
3878 </li>
3879 <li class="listitem">
3880 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm46495624339248-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>
3881
3882
3883
3884
3885 </p>
3886 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. </p>
3887 <p>
3888 </p>
3889 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the erased elements and iterators pointing to the elements in front of the erased range (towards the beginning). </p>
3890 <p>
3891 </p>
3892 <p><b>Complexity.&#160;</b>Linear (in <code class="computeroutput">std::distance(begin(), last)</code>). </p>
3893 <p>
3894 </p>
3895 <div class="note"><table border="0" summary="Note">
3896 <tr>
3897 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
3898 <th align="left">Note</th>
3899 </tr>
3900 <tr><td align="left" valign="top"><p>This method is symmetric to the <code class="computeroutput">erase(iterator, iterator)</code> method and is more effective than <code class="computeroutput">erase(iterator, iterator)</code> if <code class="computeroutput">std::distance(begin(), first)</code> is lower that <code class="computeroutput">std::distance(last, end())</code>. </p></td></tr>
3901 </table></div>
3902 <p>
3903 </p>
3904 <p><span class="bold"><strong>See Also:</strong></span></p>
3905 <p><code class="computeroutput">erase(iterator)</code>, <code class="computeroutput">erase(iterator, iterator)</code>, <code class="computeroutput">rerase(iterator)</code>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p>
3906 <p>
3907 </p>
3908 <p>
3909 </p>
3910 <div class="variablelist"><table border="0" class="variablelist compact">
3911 <colgroup>
3912 <col align="left" valign="top">
3913 <col>
3914 </colgroup>
3915 <tbody>
3916 <tr>
3917 <td><p><span class="term">Parameters:</span></p></td>
3918 <td><div class="variablelist"><table border="0" class="variablelist compact">
3919 <colgroup>
3920 <col align="left" valign="top">
3921 <col>
3922 </colgroup>
3923 <tbody>
3924 <tr>
3925 <td><p><span class="term"><code class="computeroutput">first</code></span></p></td>
3926 <td><p>The beginning of the range to be removed. </p></td>
3927 </tr>
3928 <tr>
3929 <td><p><span class="term"><code class="computeroutput">last</code></span></p></td>
3930 <td><p>The end of the range to be removed. </p></td>
3931 </tr>
3932 </tbody>
3933 </table></div></td>
3934 </tr>
3935 <tr>
3936 <td><p><span class="term">Requires:</span></p></td>
3937 <td><p>Valid range <code class="computeroutput">[first, last)</code>. </p></td>
3938 </tr>
3939 <tr>
3940 <td><p><span class="term">Postconditions:</span></p></td>
3941 <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.) </p></td>
3942 </tr>
3943 <tr>
3944 <td><p><span class="term">Returns:</span></p></td>
3945 <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>
3946 </tr>
3947 <tr>
3948 <td><p><span class="term">Throws:</span></p></td>
3949 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
3950 </tr>
3951 </tbody>
3952 </table></div>
3953 </li>
3954 <li class="listitem">
3955 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624319920-bb"></a><span class="identifier">erase_begin</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span><span class="special">;</span></pre>Remove first <code class="computeroutput">n</code> elements (with constant complexity for scalar types). <p>
3956
3957
3958
3959 </p>
3960 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. (I.e. no throw in case of scalars.) </p>
3961 <p>
3962 </p>
3963 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the first <code class="computeroutput">n</code> erased elements. </p>
3964 <p>
3965 </p>
3966 <p><b>Complexity.&#160;</b>Constant (in <code class="computeroutput">n</code>) for scalar types; linear for other types. </p>
3967 <p>
3968 </p>
3969 <div class="note"><table border="0" summary="Note">
3970 <tr>
3971 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
3972 <th align="left">Note</th>
3973 </tr>
3974 <tr><td align="left" valign="top"><p>This method has been specially designed for types which do not require an explicit destructruction (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which makes it possible to implement the "erase from beginning" operation with a constant complexity. For non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the implementation is actually equivalent to <code class="computeroutput">rerase(begin(), begin() + n)</code>. </p></td></tr>
3975 </table></div>
3976 <p>
3977 </p>
3978 <p><span class="bold"><strong>See Also:</strong></span></p>
3979 <p><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>, <code class="computeroutput">erase_end(size_type)</code>, <code class="computeroutput">clear()</code> </p>
3980 <p>
3981 </p>
3982 <p>
3983 </p>
3984 <div class="variablelist"><table border="0" class="variablelist compact">
3985 <colgroup>
3986 <col align="left" valign="top">
3987 <col>
3988 </colgroup>
3989 <tbody>
3990 <tr>
3991 <td><p><span class="term">Parameters:</span></p></td>
3992 <td><div class="variablelist"><table border="0" class="variablelist compact">
3993 <colgroup>
3994 <col align="left" valign="top">
3995 <col>
3996 </colgroup>
3997 <tbody><tr>
3998 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
3999 <td><p>The number of elements to be removed. </p></td>
4000 </tr></tbody>
4001 </table></div></td>
4002 </tr>
4003 <tr>
4004 <td><p><span class="term">Requires:</span></p></td>
4005 <td><p><code class="computeroutput">n &lt;= size()</code> </p></td>
4006 </tr>
4007 <tr>
4008 <td><p><span class="term">Postconditions:</span></p></td>
4009 <td><p>The <code class="computeroutput">n</code> elements at the beginning of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be removed. </p></td>
4010 </tr>
4011 <tr>
4012 <td><p><span class="term">Throws:</span></p></td>
4013 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
4014 </tr>
4015 </tbody>
4016 </table></div>
4017 </li>
4018 <li class="listitem">
4019 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624303152-bb"></a><span class="identifier">erase_end</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span><span class="special">;</span></pre>Remove last <code class="computeroutput">n</code> elements (with constant complexity for scalar types). <p>
4020
4021
4022
4023 </p>
4024 <p><b>Exception Safety.&#160;</b>Basic; no-throw if the operation in the <span class="emphasis"><em>Throws</em></span> section does not throw anything. (I.e. no throw in case of scalars.) </p>
4025 <p>
4026 </p>
4027 <p><b>Iterator Invalidation.&#160;</b>Invalidates iterators pointing to the last <code class="computeroutput">n</code> erased elements. </p>
4028 <p>
4029 </p>
4030 <p><b>Complexity.&#160;</b>Constant (in <code class="computeroutput">n</code>) for scalar types; linear for other types. </p>
4031 <p>
4032 </p>
4033 <div class="note"><table border="0" summary="Note">
4034 <tr>
4035 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
4036 <th align="left">Note</th>
4037 </tr>
4038 <tr><td align="left" valign="top"><p>This method has been specially designed for types which do not require an explicit destructruction (e.g. integer, float or a pointer). For these scalar types a call to a destructor is not required which makes it possible to implement the "erase from end" operation with a constant complexity. For non-sacalar types the complexity is linear (hence the explicit destruction is needed) and the implementation is actually equivalent to <code class="computeroutput">erase(end() - n, end())</code>. </p></td></tr>
4039 </table></div>
4040 <p>
4041 </p>
4042 <p><span class="bold"><strong>See Also:</strong></span></p>
4043 <p><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>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">clear()</code> </p>
4044 <p>
4045 </p>
4046 <p>
4047 </p>
4048 <div class="variablelist"><table border="0" class="variablelist compact">
4049 <colgroup>
4050 <col align="left" valign="top">
4051 <col>
4052 </colgroup>
4053 <tbody>
4054 <tr>
4055 <td><p><span class="term">Parameters:</span></p></td>
4056 <td><div class="variablelist"><table border="0" class="variablelist compact">
4057 <colgroup>
4058 <col align="left" valign="top">
4059 <col>
4060 </colgroup>
4061 <tbody><tr>
4062 <td><p><span class="term"><code class="computeroutput">n</code></span></p></td>
4063 <td><p>The number of elements to be removed. </p></td>
4064 </tr></tbody>
4065 </table></div></td>
4066 </tr>
4067 <tr>
4068 <td><p><span class="term">Requires:</span></p></td>
4069 <td><p><code class="computeroutput">n &lt;= size()</code> </p></td>
4070 </tr>
4071 <tr>
4072 <td><p><span class="term">Postconditions:</span></p></td>
4073 <td><p>The <code class="computeroutput">n</code> elements at the end of the <code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code> will be removed. </p></td>
4074 </tr>
4075 <tr>
4076 <td><p><span class="term">Throws:</span></p></td>
4077 <td>&lt;a href="circular_buffer/implementation.html#circular_buffer.implementation.exceptions_of_move_if_noexcept_t"&gt;Exceptions of move_if_noexcept(T&amp;). </td>
4078 </tr>
4079 </tbody>
4080 </table></div>
4081 </li>
4082 <li class="listitem">
4083 <pre class="literallayout"><span class="keyword">void</span> <a name="idm46495624286400-bb"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>Remove all stored elements from the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>. <p>
4084
4085 </p>
4086 <p><b>Exception Safety.&#160;</b>No-throw. </p>
4087 <p>
4088 </p>
4089 <p><b>Iterator Invalidation.&#160;</b>Invalidates all iterators pointing to the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code> (except iterators equal to <code class="computeroutput">end()</code>). </p>
4090 <p>
4091 </p>
4092 <p><b>Complexity.&#160;</b>Constant (in the size of the <code class="computeroutput"><code class="computeroutput"><a class="link" href="circular_buffer.html" title="Class template circular_buffer">circular_buffer</a></code></code>) for scalar types; linear for other types. </p>
4093 <p>
4094 </p>
4095 <p><span class="bold"><strong>See Also:</strong></span></p>
4096 <p><code class="computeroutput">~circular_buffer()</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>, <code class="computeroutput">erase_begin(size_type)</code>, <code class="computeroutput">erase_end(size_type)</code> </p>
4097 <p>
4098 </p>
4099 <p>
4100 </p>
4101 <div class="variablelist"><table border="0" class="variablelist compact">
4102 <colgroup>
4103 <col align="left" valign="top">
4104 <col>
4105 </colgroup>
4106 <tbody>
4107 <tr>
4108 <td><p><span class="term">Postconditions:</span></p></td>
4109 <td><p><code class="computeroutput">size() == 0</code> </p></td>
4110 </tr>
4111 <tr>
4112 <td><p><span class="term">Throws:</span></p></td>
4113 <td>Nothing. </td>
4114 </tr>
4115 </tbody>
4116 </table></div>
4117 </li>
4118 </ol></div>
4119 </div>
4120 </div>
4121 </div>
4122 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
4123 <td align="left"></td>
4124 <td align="right"><div class="copyright-footer">Copyright &#169; 2003-2013 Jan Gaspar<p>
4125         Distributed under the Boost Software License, Version 1.0. (See accompanying
4126         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>)
4127       </p>
4128 </div></td>
4129 </tr></table>
4130 <hr>
4131 <div class="spirit-nav">
4132 <a accesskey="p" href="../BOOST_CB_ENABLE_DEBUG.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.base_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="operator_idm46495624142096.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
4133 </div>
4134 </body>
4135 </html>