doc/html/boost/container/flat_multiset.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 flat_multiset</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_container_header_reference.html#header.boost.container.flat_set_hpp" title="Header &lt;boost/container/flat_set.hpp&gt;">
  10 <link rel="prev" href="pmr/flat_multimap_of.html" title="Struct template flat_multimap_of">
  11 <link rel="next" href="flat_set.html" title="Class template flat_set">
  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="pmr/flat_multimap_of.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.flat_set_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="flat_set.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
  25 </div>
  26 <div class="refentry">
  27 <a name="boost.container.flat_multiset"></a><div class="titlepage"></div>
  28 <div class="refnamediv">
  29 <h2><span class="refentrytitle">Class template flat_multiset</span></h2>
  30 <p>boost::container::flat_multiset</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_container_header_reference.html#header.boost.container.flat_set_hpp" title="Header &lt;boost/container/flat_set.hpp&gt;">boost/container/flat_set.hpp</a>&gt;
  34
  35 </span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span>
  36          <span class="keyword">typename</span> AllocatorOrContainer <span class="special">=</span> <a class="link" href="new_allocator.html" title="Class template new_allocator">new_allocator</a><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  37 <span class="keyword">class</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">{</span>
  38 <span class="keyword">public</span><span class="special">:</span>
  39   <span class="comment">// types</span>
  40   <span class="keyword">typedef</span> <span class="identifier">Key</span>                                                    <a name="boost.container.flat_multiset.key_type"></a><span class="identifier">key_type</span><span class="special">;</span>
  41   <span class="keyword">typedef</span> <span class="identifier">Compare</span>                                                <a name="boost.container.flat_multiset.key_compare"></a><span class="identifier">key_compare</span><span class="special">;</span>
  42   <span class="keyword">typedef</span> <span class="identifier">Key</span>                                                    <a name="boost.container.flat_multiset.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>
  43   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multiset.sequence_type"></a><span class="identifier">sequence_type</span><span class="special">;</span>
  44   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">allocator_type</span>                          <a name="boost.container.flat_multiset.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span>
  45   <span class="keyword">typedef</span> <span class="special">::</span><a class="link" href="allocator_traits.html" title="Struct template allocator_traits">boost::container::allocator_traits</a><span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span> <a name="boost.container.flat_multiset.allocator_traits_type"></a><span class="identifier">allocator_traits_type</span><span class="special">;</span>
  46   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">pointer</span>                                 <a name="boost.container.flat_multiset.pointer"></a><span class="identifier">pointer</span><span class="special">;</span>
  47   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_pointer</span>                           <a name="boost.container.flat_multiset.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>
  48   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">reference</span>                               <a name="boost.container.flat_multiset.reference"></a><span class="identifier">reference</span><span class="special">;</span>
  49   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_reference</span>                         <a name="boost.container.flat_multiset.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>
  50   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">size_type</span>                               <a name="boost.container.flat_multiset.size_type"></a><span class="identifier">size_type</span><span class="special">;</span>
  51   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">difference_type</span>                         <a name="boost.container.flat_multiset.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span>
  52   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multiset.stored_allocator_type"></a><span class="identifier">stored_allocator_type</span><span class="special">;</span>
  53   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multiset.value_compare"></a><span class="identifier">value_compare</span><span class="special">;</span>
  54   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">iterator</span>                                <a name="boost.container.flat_multiset.iterator"></a><span class="identifier">iterator</span><span class="special">;</span>
  55   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_iterator</span>                          <a name="boost.container.flat_multiset.const_iterator"></a><span class="identifier">const_iterator</span><span class="special">;</span>
  56   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">reverse_iterator</span>                        <a name="boost.container.flat_multiset.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>
  57   <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_reverse_iterator</span>                  <a name="boost.container.flat_multiset.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
  58
  59   <span class="comment">// <a class="link" href="flat_multiset.html#boost.container.flat_multisetconstruct-copy-destruct">construct/copy/destruct</a></span>
  60   <a class="link" href="flat_multiset.html#idm45666072897936-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  61   <span class="keyword">explicit</span> <a class="link" href="flat_multiset.html#idm45666072895392-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  62   <span class="keyword">explicit</span> <a class="link" href="flat_multiset.html#idm45666072892272-bb"><span class="identifier">flat_multiset</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="special">;</span>
  63   <a class="link" href="flat_multiset.html#idm45666072889152-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><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="special">;</span>
  64   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <a class="link" href="flat_multiset.html#idm45666072885600-bb"><span class="identifier">flat_multiset</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>
  65   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  66     <a class="link" href="flat_multiset.html#idm45666072881104-bb"><span class="identifier">flat_multiset</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="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  67   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  68     <a class="link" href="flat_multiset.html#idm45666072875888-bb"><span class="identifier">flat_multiset</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="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  69   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  70     <a class="link" href="flat_multiset.html#idm45666072870656-bb"><span class="identifier">flat_multiset</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="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span>
  71                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  72   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  73     <a class="link" href="flat_multiset.html#idm45666072864720-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</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>
  74   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  75     <a class="link" href="flat_multiset.html#idm45666072856944-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  76                   <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  77   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  78     <a class="link" href="flat_multiset.html#idm45666072848448-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  79                   <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><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="special">;</span>
  80   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  81     <a class="link" href="flat_multiset.html#idm45666072839248-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span>
  82                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  83   <a class="link" href="flat_multiset.html#idm45666072830752-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  84   <a class="link" href="flat_multiset.html#idm45666072827904-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><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="special">;</span>
  85   <a class="link" href="flat_multiset.html#idm45666072824176-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  86   <a class="link" href="flat_multiset.html#idm45666072820448-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span>
  87                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  88   <a class="link" href="flat_multiset.html#idm45666072816016-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  89   <a class="link" href="flat_multiset.html#idm45666072810448-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span>
  90                 <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  91   <a class="link" href="flat_multiset.html#idm45666072804160-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span>
  92                 <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><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="special">;</span>
  93   <a class="link" href="flat_multiset.html#idm45666072797168-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  94   <a class="link" href="flat_multiset.html#idm45666072793904-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  95   <a class="link" href="flat_multiset.html#idm45666072789584-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><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="special">;</span>
  96   <a class="link" href="flat_multiset.html#idm45666072785600-bb"><span class="identifier">flat_multiset</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span><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="special">;</span>
  97   <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> <a class="link" href="flat_multiset.html#idm45666072781712-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  98   <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span>
  99   <a class="link" href="flat_multiset.html#idm45666072777872-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">propagate_on_container_move_assignment</span><span class="special">::</span><span class="identifier">value</span><span class="special">||</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
 100   <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> <a class="link" href="flat_multiset.html#idm45666072773504-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
 101
 102   <span class="comment">// <a class="link" href="flat_multiset.html#idm45666073181664-bb">public member functions</a></span>
 103   <span class="identifier">allocator_type</span> <a class="link" href="flat_multiset.html#idm45666073181104-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>
 104   <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="flat_multiset.html#idm45666073178096-bb"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 105   <span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="flat_multiset.html#idm45666073173408-bb"><span class="identifier">get_stored_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>
 106   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073168704-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 107   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666073164864-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 108   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666073161008-bb"><span class="identifier">cbegin</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">iterator</span> <a class="link" href="flat_multiset.html#idm45666073157152-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 110   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666073153328-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>
 111   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666073149504-bb"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 112   <span class="identifier">reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073145680-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 113   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073141824-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>
 114   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073137968-bb"><span class="identifier">crbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 115   <span class="identifier">reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073134112-bb"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 116   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073130256-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>
 117   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multiset.html#idm45666073126400-bb"><span class="identifier">crend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 118   <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666073122544-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>
 119   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666073118720-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>
 120   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666073114880-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>
 121   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666073111056-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>
 122   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073107168-bb"><span class="identifier">reserve</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
 123   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073102080-bb"><span class="identifier">shrink_to_fit</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 124   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073098480-bb"><span class="identifier">emplace</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
 125   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073092880-bb"><span class="identifier">emplace_hint</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
 126   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073085632-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 127   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073081232-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 128   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073076800-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 129   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073070736-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 130   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073064656-bb"><span class="identifier">insert</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>
 131   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 132     <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073057952-bb"><span class="identifier">insert</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</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>
 133   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073050288-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
 134   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073045968-bb"><span class="identifier">insert</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
 135   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 136     <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073039824-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 137   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 138     <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073032336-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</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> C2<span class="special">&gt;</span>
 140     <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073024848-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_set.html" title="Class template flat_set">flat_set</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 141   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 142     <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666073017360-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_set.html" title="Class template flat_set">flat_set</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 143   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073009872-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
 144   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666073004592-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 145   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666073000240-bb"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
 146   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666072994368-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_swappable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
 147   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666072989472-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="identifier">key_compare</span> <a class="link" href="flat_multiset.html#idm45666072985680-bb"><span class="identifier">key_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 149   <span class="identifier">value_compare</span> <a class="link" href="flat_multiset.html#idm45666072982688-bb"><span class="identifier">value_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 150   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666072979680-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 151   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666072976224-bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 152   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666072972496-bb"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 153   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666072966208-bb"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 154   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666072959920-bb"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 155   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666072953648-bb"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 156   <span class="identifier">size_type</span> <a class="link" href="flat_multiset.html#idm45666072947376-bb"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 157   <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072943712-bb"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 158   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072940000-bb"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 159   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666072934528-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 160   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666072931072-bb"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 161   <span class="identifier">iterator</span> <a class="link" href="flat_multiset.html#idm45666072927344-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 162   <span class="identifier">const_iterator</span> <a class="link" href="flat_multiset.html#idm45666072923888-bb"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 163   <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span>
 164   <a class="link" href="flat_multiset.html#idm45666072920160-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 165   <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="flat_multiset.html#idm45666072916432-bb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 166   <span class="identifier">sequence_type</span> <a class="link" href="flat_multiset.html#idm45666072912992-bb"><span class="identifier">extract_sequence</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 167   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666072908512-bb"><span class="identifier">adopt_sequence</span></a><span class="special">(</span><span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 168   <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666072904128-bb"><span class="identifier">adopt_sequence</span></a><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 169
 170   <span class="comment">// <a class="link" href="flat_multiset.html#idm45666072770096-bb">friend functions</a></span>
 171   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072769536-bb"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 172   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072764544-bb"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 173   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072759552-bb"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 174   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072754560-bb"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 175   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072749568-bb"><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 176   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multiset.html#idm45666072744560-bb"><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 177   <span class="keyword">friend</span> <span class="keyword">void</span> <a class="link" href="flat_multiset.html#idm45666072739552-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 178 <span class="special">}</span><span class="special">;</span></pre></div>
 179 <div class="refsect1">
 180 <a name="id-1.3.10.14.10.3.4"></a><h2>Description</h2>
 181 <p><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> is a Sorted Associative Container that stores objects of type Key and can store multiple copies of the same key value.</p>
 182 <p><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> is similar to std::multiset but it's implemented by as an ordered sequence container. The underlying sequence container is by default <span class="emphasis"><em>vector</em></span> but it can also work user-provided vector-like SequenceContainers (like <span class="emphasis"><em><a class="link" href="static_vector.html" title="Class template static_vector">static_vector</a></em></span> or <span class="emphasis"><em><a class="link" href="small_vector.html" title="Class template small_vector">small_vector</a></em></span>).</p>
 183 <p>Using vector-like sequence containers means that inserting a new element into a <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> might invalidate previous iterators and references (unless that sequence container is <span class="emphasis"><em><a class="link" href="stable_vector.html" title="Class template stable_vector">stable_vector</a></em></span> or a similar container that offers stable pointers and references). Similarly, erasing an element might invalidate iterators and references pointing to elements that come after (their keys are bigger) the erased element.</p>
 184 <p>This container provides random-access iterators.</p>
 185 <p>
 186 </p>
 187 <div class="refsect2">
 188 <a name="id-1.3.10.14.10.3.4.7"></a><h3>Template Parameters</h3>
 189 <div class="orderedlist"><ol class="orderedlist" type="1">
 190 <li class="listitem">
 191 <pre class="literallayout"><span class="keyword">typename</span> Key</pre>
 192 <p>is the type to be inserted in the multiset, which is also the key_type </p>
 193 </li>
 194 <li class="listitem">
 195 <pre class="literallayout"><span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span></pre>
 196 <p>is the comparison functor used to order keys </p>
 197 </li>
 198 <li class="listitem">
 199 <pre class="literallayout"><span class="keyword">typename</span> AllocatorOrContainer <span class="special">=</span> <a class="link" href="new_allocator.html" title="Class template new_allocator">new_allocator</a><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span></pre>
 200 <p>is either:</p>
 201 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 202 <li class="listitem"><p>The allocator to allocate <code class="computeroutput">value_type</code>s (e.g. <span class="emphasis"><em>allocator&lt; std::pair&lt;Key, T&gt; &gt; </em></span>). (in this case <span class="emphasis"><em>sequence_type</em></span> will be vector&lt;value_type, AllocatorOrContainer&gt;)</p></li>
 203 <li class="listitem"><p>The SequenceContainer to be used as the underlying <span class="emphasis"><em>sequence_type</em></span>. It must be a vector-like sequence container with random-access iterators. </p></li>
 204 </ul></div>
 205 <p>
 206 </p>
 207 </li>
 208 </ol></div>
 209 </div>
 210 <div class="refsect2">
 211 <a name="id-1.3.10.14.10.3.4.8"></a><h3>
 212 <a name="boost.container.flat_multisetconstruct-copy-destruct"></a><code class="computeroutput">flat_multiset</code>
 213         public
 214        construct/copy/destruct</h3>
 215 <div class="orderedlist"><ol class="orderedlist" type="1">
 216 <li class="listitem">
 217 <pre class="literallayout"><a name="idm45666072897936-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_default_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
 218 <p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty container.</p>
 219 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 220 </li>
 221 <li class="listitem">
 222 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666072895392-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
 223 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object.</p>
 224 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 225 </li>
 226 <li class="listitem">
 227 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666072892272-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 228 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified allocator.</p>
 229 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 230 </li>
 231 <li class="listitem">
 232 <pre class="literallayout"><a name="idm45666072889152-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 233 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and allocator.</p>
 234 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 235 </li>
 236 <li class="listitem">
 237 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 238   <a name="idm45666072885600-bb"></a><span class="identifier">flat_multiset</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>
 239 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container and inserts elements from the range [first ,last ).</p>
 240 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. </p>
 241 </li>
 242 <li class="listitem">
 243 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 244   <a name="idm45666072881104-bb"></a><span class="identifier">flat_multiset</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>
 245                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 246 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified allocator, and inserts elements from the range [first ,last ).</p>
 247 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. </p>
 248 </li>
 249 <li class="listitem">
 250 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 251   <a name="idm45666072875888-bb"></a><span class="identifier">flat_multiset</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="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
 252 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and inserts elements from the range [first ,last ).</p>
 253 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. </p>
 254 </li>
 255 <li class="listitem">
 256 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 257   <a name="idm45666072870656-bb"></a><span class="identifier">flat_multiset</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="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span>
 258                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 259 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and allocator, and inserts elements from the range [first ,last ).</p>
 260 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. </p>
 261 </li>
 262 <li class="listitem">
 263 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 264   <a name="idm45666072864720-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><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>
 265 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a></code> and inserts elements from the ordered range [first ,last ). This function is more efficient than the normal range creation for ordered ranges.</p>
 266 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 267 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 268 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 269 </li>
 270 <li class="listitem">
 271 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 272   <a name="idm45666072856944-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
 273                 <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
 274 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a></code> using the specified comparison object and inserts elements from the ordered range [first ,last ). This function is more efficient than the normal range creation for ordered ranges.</p>
 275 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 276 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 277 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 278 </li>
 279 <li class="listitem">
 280 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 281   <a name="idm45666072848448-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
 282                 <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 283 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a></code> using the specified comparison object and allocator, and inserts elements from the ordered range [first, last ). This function is more efficient than the normal range creation for ordered ranges.</p>
 284 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 285 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 286 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 287 </li>
 288 <li class="listitem">
 289 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 290   <a name="idm45666072839248-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span>
 291                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 292 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a></code> using the specified allocator and inserts elements from the ordered range [first ,last ). This function is more efficient than the normal range creation for ordered ranges.</p>
 293 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 294 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 295 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 296 </li>
 297 <li class="listitem">
 298 <pre class="literallayout"><a name="idm45666072830752-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
 299 <p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty container.</p>
 300 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 301 </li>
 302 <li class="listitem">
 303 <pre class="literallayout"><a name="idm45666072827904-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span>
 304               <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 305 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified allocator, and inserts elements from the range [il.begin(), il.end()).</p>
 306 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using comp and otherwise N logN, where N is il.begin() - il.end(). </p>
 307 </li>
 308 <li class="listitem">
 309 <pre class="literallayout"><a name="idm45666072824176-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
 310 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and inserts elements from the range [il.begin(), il.end()).</p>
 311 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using comp and otherwise N logN, where N is il.begin() - il.end(). </p>
 312 </li>
 313 <li class="listitem">
 314 <pre class="literallayout"><a name="idm45666072820448-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span>
 315               <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 316 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).</p>
 317 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using comp and otherwise N logN, where N is il.begin() - il.end(). </p>
 318 </li>
 319 <li class="listitem">
 320 <pre class="literallayout"><a name="idm45666072816016-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
 321 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty containerand inserts elements from the ordered unique range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 322 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 323 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 324 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 325 </li>
 326 <li class="listitem">
 327 <pre class="literallayout"><a name="idm45666072810448-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span>
 328               <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
 329 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and inserts elements from the ordered unique range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 330 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 331 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 332 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 333 </li>
 334 <li class="listitem">
 335 <pre class="literallayout"><a name="idm45666072804160-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span>
 336               <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 337 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty container using the specified comparison object and allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 338 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 339 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 340 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 341 </li>
 342 <li class="listitem">
 343 <pre class="literallayout"><a name="idm45666072797168-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 344 <p><span class="bold"><strong>Effects</strong></span>: Copy constructs the container.</p>
 345 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 346 </li>
 347 <li class="listitem">
 348 <pre class="literallayout"><a name="idm45666072793904-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_constructible</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
 349 <p><span class="bold"><strong>Effects</strong></span>: Move constructs thecontainer. Constructs *this using x's resources.</p>
 350 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 351 <p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
 352 </li>
 353 <li class="listitem">
 354 <pre class="literallayout"><a name="idm45666072789584-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 355 <p><span class="bold"><strong>Effects</strong></span>: Copy constructs a container using the specified allocator.</p>
 356 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 357 </li>
 358 <li class="listitem">
 359 <pre class="literallayout"><a name="idm45666072785600-bb"></a><span class="identifier">flat_multiset</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
 360 <p><span class="bold"><strong>Effects</strong></span>: Move constructs a container using the specified allocator. Constructs *this using x's resources.</p>
 361 <p><span class="bold"><strong>Complexity</strong></span>: Constant if a == x.get_allocator(), linear otherwise </p>
 362 </li>
 363 <li class="listitem">
 364 <pre class="literallayout"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> <a name="idm45666072781712-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 365 <p><span class="bold"><strong>Effects</strong></span>: Makes *this a copy of x.</p>
 366 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 367 </li>
 368 <li class="listitem">
 369 <pre class="literallayout"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span>
 370 <a name="idm45666072777872-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">propagate_on_container_move_assignment</span><span class="special">::</span><span class="identifier">value</span><span class="special">||</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_move_assignable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
 371 <p><span class="bold"><strong>Throws</strong></span>: If allocator_traits_type::propagate_on_container_move_assignment is false and (allocation throws or value_type's move constructor throws)</p>
 372 <p><span class="bold"><strong>Complexity</strong></span>: Constant if allocator_traits_type:: propagate_on_container_move_assignment is true or this-&gt;get&gt;allocator() == x.get_allocator(). Linear otherwise. </p>
 373 </li>
 374 <li class="listitem">
 375 <pre class="literallayout"><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> <a name="idm45666072773504-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
 376 <p><span class="bold"><strong>Effects</strong></span>: Copy all elements from il to *this.</p>
 377 <p><span class="bold"><strong>Complexity</strong></span>: Linear in il.size(). </p>
 378 </li>
 379 </ol></div>
 380 </div>
 381 <div class="refsect2">
 382 <a name="id-1.3.10.14.10.3.4.9"></a><h3>
 383 <a name="idm45666073181664-bb"></a><code class="computeroutput">flat_multiset</code> public member functions</h3>
 384 <div class="orderedlist"><ol class="orderedlist" type="1">
 385 <li class="listitem">
 386 <pre class="literallayout"><span class="identifier">allocator_type</span> <a name="idm45666073181104-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>
 387 <p><span class="bold"><strong>Effects</strong></span>: Returns a copy of the allocator that was passed to the object's constructor.</p>
 388 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 389 </li>
 390 <li class="listitem">
 391 <pre class="literallayout"><span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45666073178096-bb"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 392 <p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
 393 <p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
 394 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 395 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 396 </li>
 397 <li class="listitem">
 398 <pre class="literallayout"><span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45666073173408-bb"></a><span class="identifier">get_stored_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>
 399 <p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
 400 <p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
 401 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 402 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 403 </li>
 404 <li class="listitem">
 405 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073168704-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>
 406 <p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the first element contained in the container.</p>
 407 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 408 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 409 </li>
 410 <li class="listitem">
 411 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073164864-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 412 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
 413 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 414 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 415 </li>
 416 <li class="listitem">
 417 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073161008-bb"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 418 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
 419 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 420 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 421 </li>
 422 <li class="listitem">
 423 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073157152-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>
 424 <p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the end of the container.</p>
 425 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 426 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 427 </li>
 428 <li class="listitem">
 429 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073153328-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>
 430 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
 431 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 432 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 433 </li>
 434 <li class="listitem">
 435 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073149504-bb"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 436 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
 437 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 438 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 439 </li>
 440 <li class="listitem">
 441 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45666073145680-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>
 442 <p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the beginning of the reversed container.</p>
 443 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 444 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 445 </li>
 446 <li class="listitem">
 447 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666073141824-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>
 448 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
 449 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 450 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 451 </li>
 452 <li class="listitem">
 453 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666073137968-bb"></a><span class="identifier">crbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 454 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
 455 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 456 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 457 </li>
 458 <li class="listitem">
 459 <pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="idm45666073134112-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>
 460 <p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the end of the reversed container.</p>
 461 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 462 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 463 </li>
 464 <li class="listitem">
 465 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666073130256-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>
 466 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
 467 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 468 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 469 </li>
 470 <li class="listitem">
 471 <pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="idm45666073126400-bb"></a><span class="identifier">crend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 472 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
 473 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 474 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 475 </li>
 476 <li class="listitem">
 477 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm45666073122544-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>
 478 <p><span class="bold"><strong>Effects</strong></span>: Returns true if the container contains no elements.</p>
 479 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 480 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 481 </li>
 482 <li class="listitem">
 483 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073118720-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>
 484 <p><span class="bold"><strong>Effects</strong></span>: Returns the number of the elements contained in the container.</p>
 485 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 486 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 487 </li>
 488 <li class="listitem">
 489 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073114880-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>
 490 <p><span class="bold"><strong>Effects</strong></span>: Returns the largest possible size of the container.</p>
 491 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 492 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 493 </li>
 494 <li class="listitem">
 495 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073111056-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>
 496 <p><span class="bold"><strong>Effects</strong></span>: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().</p>
 497 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 498 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 499 </li>
 500 <li class="listitem">
 501 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073107168-bb"></a><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">size_type</span> cnt<span class="special">)</span><span class="special">;</span></pre>
 502 <p><span class="bold"><strong>Effects</strong></span>: If n is less than or equal to capacity(), or the underlying container has no <code class="computeroutput">reserve</code> member, this call has no effect. Otherwise, it is a request for allocation of additional memory. If the request is successful, then capacity() is greater than or equal to n; otherwise, capacity() is unchanged. In either case, size() is unchanged.</p>
 503 <p><span class="bold"><strong>Throws</strong></span>: If memory allocation allocation throws or T's copy constructor throws.</p>
 504 <p><span class="bold"><strong>Note</strong></span>: If capacity() is less than "cnt", iterators and references to to values might be invalidated. </p>
 505 </li>
 506 <li class="listitem">
 507 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073102080-bb"></a><span class="identifier">shrink_to_fit</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
 508 <span class="bold"><strong>Effects</strong></span>: Tries to deallocate the excess of memory created <p><span class="bold"><strong>Throws</strong></span>: If memory allocation throws, or Key's copy constructor throws.</p>
 509 <p><span class="bold"><strong>Complexity</strong></span>: Linear to size(). </p>
 510 </li>
 511 <li class="listitem">
 512 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="idm45666073098480-bb"></a><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
 513 <p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type Key constructed with std::forward&lt;Args&gt;(args)... and returns the iterator pointing to the newly inserted element.</p>
 514 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 515 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 516 </li>
 517 <li class="listitem">
 518 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span>
 519   <span class="identifier">iterator</span> <a name="idm45666073092880-bb"></a><span class="identifier">emplace_hint</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
 520 <p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type Key constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
 521 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 522 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant if x is inserted right before p) plus insertion linear to the elements with bigger keys than x.</p>
 523 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 524 </li>
 525 <li class="listitem">
 526 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073085632-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 527 <p><span class="bold"><strong>Effects</strong></span>: Inserts x and returns the iterator pointing to the newly inserted element.</p>
 528 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 529 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 530 </li>
 531 <li class="listitem">
 532 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073081232-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 533 <p><span class="bold"><strong>Effects</strong></span>: Inserts a new value_type move constructed from x and returns the iterator pointing to the newly inserted element.</p>
 534 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 535 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 536 </li>
 537 <li class="listitem">
 538 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073076800-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 539 <p><span class="bold"><strong>Effects</strong></span>: Inserts a copy of x in the container. p is a hint pointing to where the insert should start to search.</p>
 540 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 541 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant if x is inserted right before p) plus insertion linear to the elements with bigger keys than x.</p>
 542 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 543 </li>
 544 <li class="listitem">
 545 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073070736-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 546 <p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
 547 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 548 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant if x is inserted right before p) plus insertion linear to the elements with bigger keys than x.</p>
 549 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 550 </li>
 551 <li class="listitem">
 552 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 553   <span class="keyword">void</span> <a name="idm45666073064656-bb"></a><span class="identifier">insert</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>
 554 <p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
 555 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .</p>
 556 <p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
 557 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 558 </li>
 559 <li class="listitem">
 560 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 561   <span class="keyword">void</span> <a name="idm45666073057952-bb"></a><span class="identifier">insert</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><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>
 562 <p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this and must be ordered according to the predicate.</p>
 563 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .This function is more efficient than the normal range creation for ordered ranges.</p>
 564 <p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
 565 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. If an element is inserted it might invalidate elements. </p>
 566 </li>
 567 <li class="listitem">
 568 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073050288-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
 569 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()).</p>
 570 <p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
 571 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 572 </li>
 573 <li class="listitem">
 574 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073045968-bb"></a><span class="identifier">insert</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
 575 <p><span class="bold"><strong>Requires</strong></span>: Range [il.begin(), il.end()) must be ordered according to the predicate.</p>
 576 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 577 <p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
 578 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. If an element is inserted it might invalidate elements. </p>
 579 </li>
 580 <li class="listitem">
 581 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 582   <span class="keyword">void</span> <a name="idm45666073039824-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
 583 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 584 <p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
 585 <p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
 586 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 587 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 588 </li>
 589 <li class="listitem">
 590 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 591   <span class="keyword">void</span> <a name="idm45666073032336-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
 592 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 593 <p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
 594 <p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
 595 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 596 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 597 </li>
 598 <li class="listitem">
 599 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 600   <span class="keyword">void</span> <a name="idm45666073024848-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_set.html" title="Class template flat_set">flat_set</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
 601 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 602 <p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
 603 <p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
 604 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 605 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 606 </li>
 607 <li class="listitem">
 608 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 609   <span class="keyword">void</span> <a name="idm45666073017360-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_set.html" title="Class template flat_set">flat_set</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
 610 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 611 <p><span class="bold"><strong>Effects</strong></span>: Extracts each element in source and insert it into a using the comparison object of *this.</p>
 612 <p><span class="bold"><strong>Postcondition</strong></span>: Pointers and references to the transferred elements of source refer to those same elements but as members of *this. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into *this, not into source.</p>
 613 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 614 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 615 </li>
 616 <li class="listitem">
 617 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073009872-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span><span class="special">;</span></pre>
 618 <p><span class="bold"><strong>Effects</strong></span>: Erases the element pointed to by p.</p>
 619 <p><span class="bold"><strong>Returns</strong></span>: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().</p>
 620 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the elements with keys bigger than p</p>
 621 <p><span class="bold"><strong>Note</strong></span>: Invalidates elements with keys not less than the erased element. </p>
 622 </li>
 623 <li class="listitem">
 624 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073004592-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 625 <p><span class="bold"><strong>Effects</strong></span>: Erases all elements in the container with key equivalent to x.</p>
 626 <p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements.</p>
 627 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
 628 </li>
 629 <li class="listitem">
 630 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073000240-bb"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> first<span class="special">,</span> <span class="identifier">const_iterator</span> last<span class="special">)</span><span class="special">;</span></pre>
 631 <p><span class="bold"><strong>Effects</strong></span>: Erases all the elements in the range [first, last).</p>
 632 <p><span class="bold"><strong>Returns</strong></span>: Returns last.</p>
 633 <p><span class="bold"><strong>Complexity</strong></span>: size()*N where N is the distance from first to last.</p>
 634 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
 635 </li>
 636 <li class="listitem">
 637 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666072994368-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">allocator_traits_type</span><span class="special">::</span><span class="identifier">is_always_equal</span><span class="special">::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">container</span><span class="special">::</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_nothrow_swappable</span><span class="special">&lt;</span> <span class="identifier">Compare</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre>
 638 <p><span class="bold"><strong>Effects</strong></span>: Swaps the contents of *this and x.</p>
 639 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 640 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 641 </li>
 642 <li class="listitem">
 643 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666072989472-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>
 644 <p><span class="bold"><strong>Effects</strong></span>: erase(begin(),end()).</p>
 645 <p><span class="bold"><strong>Postcondition</strong></span>: size() == 0.</p>
 646 <p><span class="bold"><strong>Complexity</strong></span>: linear in size(). </p>
 647 </li>
 648 <li class="listitem">
 649 <pre class="literallayout"><span class="identifier">key_compare</span> <a name="idm45666072985680-bb"></a><span class="identifier">key_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 650 <p><span class="bold"><strong>Effects</strong></span>: Returns the comparison object out of which a was constructed.</p>
 651 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 652 </li>
 653 <li class="listitem">
 654 <pre class="literallayout"><span class="identifier">value_compare</span> <a name="idm45666072982688-bb"></a><span class="identifier">value_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 655 <p><span class="bold"><strong>Effects</strong></span>: Returns an object of value_compare constructed out of the comparison object.</p>
 656 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 657 </li>
 658 <li class="listitem">
 659 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666072979680-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 660 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
 661 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 662 </li>
 663 <li class="listitem">
 664 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666072976224-bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 665 <p><span class="bold"><strong>Returns</strong></span>: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
 666 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 667 </li>
 668 <li class="listitem">
 669 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666072972496-bb"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 670 <p><span class="bold"><strong>Requires</strong></span>: size() &gt;= n.</p>
 671 <p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the nth element from the beginning of the container. Returns end() if n == size().</p>
 672 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 673 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 674 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 675 </li>
 676 <li class="listitem">
 677 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666072966208-bb"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 678 <p><span class="bold"><strong>Requires</strong></span>: size() &gt;= n.</p>
 679 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the nth element from the beginning of the container. Returns end() if n == size().</p>
 680 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 681 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 682 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 683 </li>
 684 <li class="listitem">
 685 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666072959920-bb"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">iterator</span> p<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 686 <p><span class="bold"><strong>Requires</strong></span>: begin() &lt;= p &lt;= end().</p>
 687 <p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and size() if p == end().</p>
 688 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 689 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 690 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 691 </li>
 692 <li class="listitem">
 693 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666072953648-bb"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 694 <p><span class="bold"><strong>Requires</strong></span>: begin() &lt;= p &lt;= end().</p>
 695 <p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and size() if p == end().</p>
 696 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 697 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 698 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 699 </li>
 700 <li class="listitem">
 701 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666072947376-bb"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 702 <p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
 703 <p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
 704 </li>
 705 <li class="listitem">
 706 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm45666072943712-bb"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 707 <p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
 708 <p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
 709 </li>
 710 <li class="listitem">
 711 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a name="idm45666072940000-bb"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 712 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 713 <p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
 714 <p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
 715 </li>
 716 <li class="listitem">
 717 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666072934528-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 718 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
 719 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 720 </li>
 721 <li class="listitem">
 722 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666072931072-bb"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 723 <p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.</p>
 724 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 725 </li>
 726 <li class="listitem">
 727 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666072927344-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 728 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
 729 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 730 </li>
 731 <li class="listitem">
 732 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666072923888-bb"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 733 <p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or end() if such an element is not found.</p>
 734 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 735 </li>
 736 <li class="listitem">
 737 <pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span>
 738 <a name="idm45666072920160-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
 739 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 740 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 741 </li>
 742 <li class="listitem">
 743 <pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="idm45666072916432-bb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 744 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 745 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 746 </li>
 747 <li class="listitem">
 748 <pre class="literallayout"><span class="identifier">sequence_type</span> <a name="idm45666072912992-bb"></a><span class="identifier">extract_sequence</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
 749 <p><span class="bold"><strong>Effects</strong></span>: Extracts the internal sequence container.</p>
 750 <p><span class="bold"><strong>Complexity</strong></span>: Same as the move constructor of sequence_type, usually constant.</p>
 751 <p><span class="bold"><strong>Postcondition</strong></span>: this-&gt;empty()</p>
 752 <p><span class="bold"><strong>Throws</strong></span>: If secuence_type's move constructor throws </p>
 753 </li>
 754 <li class="listitem">
 755 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666072908512-bb"></a><span class="identifier">adopt_sequence</span><span class="special">(</span><span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span> seq<span class="special">)</span><span class="special">;</span></pre>
 756 <p><span class="bold"><strong>Effects</strong></span>: Discards the internally hold sequence container and adopts the one passed externally using the move assignment.</p>
 757 <p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()</p>
 758 <p><span class="bold"><strong>Throws</strong></span>: If the comparison or the move constructor throws </p>
 759 </li>
 760 <li class="listitem">
 761 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666072904128-bb"></a><span class="identifier">adopt_sequence</span><span class="special">(</span><a class="link" href="ordered_range_t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span> seq<span class="special">)</span><span class="special">;</span></pre>
 762 <p><span class="bold"><strong>Requires</strong></span>: seq shall be ordered according to this-&gt;compare()</p>
 763 <p><span class="bold"><strong>Effects</strong></span>: Discards the internally hold sequence container and adopts the one passed externally using the move assignment.</p>
 764 <p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(1)</p>
 765 <p><span class="bold"><strong>Throws</strong></span>: If the move assignment throws </p>
 766 </li>
 767 </ol></div>
 768 </div>
 769 <div class="refsect2">
 770 <a name="id-1.3.10.14.10.3.4.10"></a><h3>
 771 <a name="idm45666072770096-bb"></a><code class="computeroutput">flat_multiset</code> friend functions</h3>
 772 <div class="orderedlist"><ol class="orderedlist" type="1">
 773 <li class="listitem">
 774 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072769536-bb"></a><span class="keyword">operator</span><span class="special">==</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 775 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are equal</p>
 776 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 777 </li>
 778 <li class="listitem">
 779 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072764544-bb"></a><span class="keyword">operator</span><span class="special">!=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 780 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are unequal</p>
 781 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 782 </li>
 783 <li class="listitem">
 784 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072759552-bb"></a><span class="keyword">operator</span><span class="special">&lt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 785 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is less than y</p>
 786 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 787 </li>
 788 <li class="listitem">
 789 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072754560-bb"></a><span class="keyword">operator</span><span class="special">&gt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 790 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is greater than y</p>
 791 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 792 </li>
 793 <li class="listitem">
 794 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072749568-bb"></a><span class="keyword">operator</span><span class="special">&lt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 795 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or less than y</p>
 796 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 797 </li>
 798 <li class="listitem">
 799 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666072744560-bb"></a><span class="keyword">operator</span><span class="special">&gt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 800 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or greater than y</p>
 801 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 802 </li>
 803 <li class="listitem">
 804 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">void</span> <a name="idm45666072739552-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> x<span class="special">,</span> <a class="link" href="flat_multiset.html" title="Class template flat_multiset">flat_multiset</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 805 <p><span class="bold"><strong>Effects</strong></span>: x.swap(y)</p>
 806 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 807 </li>
 808 </ol></div>
 809 </div>
 810 </div>
 811 </div>
 812 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 813 <td align="left"></td>
 814 <td align="right"><div class="copyright-footer">Copyright &#169; 2009-2018 Ion Gaztanaga<p>
 815         Distributed under the Boost Software License, Version 1.0. (See accompanying
 816         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>)
 817       </p>
 818 </div></td>
 819 </tr></table>
 820 <hr>
 821 <div class="spirit-nav">
 822 <a accesskey="p" href="pmr/flat_multimap_of.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.flat_set_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="flat_set.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
 823 </div>
 824 </body>
 825 </html>