doc/html/boost/container/flat_multimap.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_multimap</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_map_hpp" title="Header &lt;boost/container/flat_map.hpp&gt;">
  10 <link rel="prev" href="flat_map.html" title="Class template flat_map">
  11 <link rel="next" href="pmr/flat_map_of.html" title="Struct template flat_map_of">
  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="flat_map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.flat_map_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="pmr/flat_map_of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
  25 </div>
  26 <div class="refentry">
  27 <a name="boost.container.flat_multimap"></a><div class="titlepage"></div>
  28 <div class="refnamediv">
  29 <h2><span class="refentrytitle">Class template flat_multimap</span></h2>
  30 <p>boost::container::flat_multimap</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_map_hpp" title="Header &lt;boost/container/flat_map.hpp&gt;">boost/container/flat_map.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> T<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">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
  37 <span class="keyword">class</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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_multimap.key_type"></a><span class="identifier">key_type</span><span class="special">;</span>
  41   <span class="keyword">typedef</span> <span class="identifier">T</span>                                                      <a name="boost.container.flat_multimap.mapped_type"></a><span class="identifier">mapped_type</span><span class="special">;</span>
  42   <span class="keyword">typedef</span> <span class="identifier">Compare</span>                                                <a name="boost.container.flat_multimap.key_compare"></a><span class="identifier">key_compare</span><span class="special">;</span>
  43   <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span>                                    <a name="boost.container.flat_multimap.value_type"></a><span class="identifier">value_type</span><span class="special">;</span>
  44   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multimap.sequence_type"></a><span class="identifier">sequence_type</span><span class="special">;</span>
  45   <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_multimap.allocator_type"></a><span class="identifier">allocator_type</span><span class="special">;</span>
  46   <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_multimap.allocator_traits_type"></a><span class="identifier">allocator_traits_type</span><span class="special">;</span>
  47   <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_multimap.pointer"></a><span class="identifier">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">const_pointer</span>                           <a name="boost.container.flat_multimap.const_pointer"></a><span class="identifier">const_pointer</span><span class="special">;</span>
  49   <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_multimap.reference"></a><span class="identifier">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">const_reference</span>                         <a name="boost.container.flat_multimap.const_reference"></a><span class="identifier">const_reference</span><span class="special">;</span>
  51   <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_multimap.size_type"></a><span class="identifier">size_type</span><span class="special">;</span>
  52   <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_multimap.difference_type"></a><span class="identifier">difference_type</span><span class="special">;</span>
  53   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multimap.stored_allocator_type"></a><span class="identifier">stored_allocator_type</span><span class="special">;</span>
  54   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multimap.value_compare"></a><span class="identifier">value_compare</span><span class="special">;</span>
  55   <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_multimap.iterator"></a><span class="identifier">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">const_iterator</span>                          <a name="boost.container.flat_multimap.const_iterator"></a><span class="identifier">const_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">reverse_iterator</span>                        <a name="boost.container.flat_multimap.reverse_iterator"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>
  58   <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_multimap.const_reverse_iterator"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
  59   <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="boost.container.flat_multimap.movable_value_type"></a><span class="identifier">movable_value_type</span><span class="special">;</span>
  60
  61   <span class="comment">// <a class="link" href="flat_multimap.html#boost.container.flat_multimapconstruct-copy-destruct">construct/copy/destruct</a></span>
  62   <a class="link" href="flat_multimap.html#idm45666073470992-bb"><span class="identifier">flat_multimap</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>
  63   <span class="keyword">explicit</span> <a class="link" href="flat_multimap.html#idm45666073467728-bb"><span class="identifier">flat_multimap</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>
  64   <span class="keyword">explicit</span> <a class="link" href="flat_multimap.html#idm45666073463904-bb"><span class="identifier">flat_multimap</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>
  65   <a class="link" href="flat_multimap.html#idm45666073460064-bb"><span class="identifier">flat_multimap</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>
  66   <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_multimap.html#idm45666073455808-bb"><span class="identifier">flat_multimap</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>
  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_multimap.html#idm45666073450592-bb"><span class="identifier">flat_multimap</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>
  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_multimap.html#idm45666073444656-bb"><span class="identifier">flat_multimap</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>
  71   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  72     <a class="link" href="flat_multimap.html#idm45666073438704-bb"><span class="identifier">flat_multimap</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>
  73                   <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</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_multimap.html#idm45666073432048-bb"><span class="identifier">flat_multimap</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>
  76   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  77     <a class="link" href="flat_multimap.html#idm45666073424272-bb"><span class="identifier">flat_multimap</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>
  78                   <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  79   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  80     <a class="link" href="flat_multimap.html#idm45666073415776-bb"><span class="identifier">flat_multimap</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>
  81                   <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>
  82   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
  83     <a class="link" href="flat_multimap.html#idm45666073406576-bb"><span class="identifier">flat_multimap</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>
  84                   <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_multimap.html#idm45666073398080-bb"><span class="identifier">flat_multimap</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>
  86   <a class="link" href="flat_multimap.html#idm45666073394368-bb"><span class="identifier">flat_multimap</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>
  87   <a class="link" href="flat_multimap.html#idm45666073389936-bb"><span class="identifier">flat_multimap</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>
  88   <a class="link" href="flat_multimap.html#idm45666073385504-bb"><span class="identifier">flat_multimap</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>
  89                 <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  90   <a class="link" href="flat_multimap.html#idm45666073380368-bb"><span class="identifier">flat_multimap</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>
  91   <a class="link" href="flat_multimap.html#idm45666073374112-bb"><span class="identifier">flat_multimap</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="special">;</span>
  93   <a class="link" href="flat_multimap.html#idm45666073367120-bb"><span class="identifier">flat_multimap</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>
  94                 <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>
  95   <a class="link" href="flat_multimap.html#idm45666073359424-bb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  96   <a class="link" href="flat_multimap.html#idm45666073355440-bb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
  97   <a class="link" href="flat_multimap.html#idm45666073350416-bb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
  98   <a class="link" href="flat_multimap.html#idm45666073345728-bb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
  99   <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a class="link" href="flat_multimap.html#idm45666073341120-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 100   <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span>
 101   <a class="link" href="flat_multimap.html#idm45666073337280-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 102   <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a class="link" href="flat_multimap.html#idm45666073333168-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>
 103
 104   <span class="comment">// <a class="link" href="flat_multimap.html#idm45666073817648-bb">public member functions</a></span>
 105    <a class="link" href="flat_multimap.html#idm45666073817088-bb"><span class="identifier">BOOST_STATIC_ASSERT</span></a><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">value_type</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>
 106   <span class="identifier">allocator_type</span> <a class="link" href="flat_multimap.html#idm45666073815664-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>
 107   <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="flat_multimap.html#idm45666073812656-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>
 108   <span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="flat_multimap.html#idm45666073807968-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>
 109   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073803264-bb"><span class="identifier">begin</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_multimap.html#idm45666073799424-bb"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
 111   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073795568-bb"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 112   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073791744-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>
 113   <span class="identifier">reverse_iterator</span> <a class="link" href="flat_multimap.html#idm45666073787920-bb"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 114   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multimap.html#idm45666073784064-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>
 115   <span class="identifier">reverse_iterator</span> <a class="link" href="flat_multimap.html#idm45666073780208-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_multimap.html#idm45666073776352-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_iterator</span> <a class="link" href="flat_multimap.html#idm45666073772496-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>
 118   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073768640-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>
 119   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multimap.html#idm45666073764816-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>
 120   <span class="identifier">const_reverse_iterator</span> <a class="link" href="flat_multimap.html#idm45666073760960-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>
 121   <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073757104-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>
 122   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073753280-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>
 123   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073749440-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>
 124   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073745616-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>
 125   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073741728-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>
 126   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073736640-bb"><span class="identifier">shrink_to_fit</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 127   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073733040-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>
 128   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073726752-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>
 129   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073720464-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>
 130   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073714192-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>
 131   <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_multimap.html#idm45666073707920-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>
 132   <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_multimap.html#idm45666073702320-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>
 133   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073695056-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>
 134   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073690656-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>
 135   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073686224-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">impl_value_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
 136   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073681792-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>
 137   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073675712-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>
 138   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073669616-bb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">impl_value_type</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> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073663520-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>
 140   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 141     <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073656816-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>
 142   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073647360-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>
 143   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073643040-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>
 144   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 145     <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073635984-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 146   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 147     <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073628496-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 148   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 149     <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073621008-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 150   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 151     <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073613520-bb"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 152   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073606032-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>
 153   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073600752-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>
 154   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073596400-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>
 155   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073590528-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 156   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073585632-bb"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
 157   <span class="identifier">key_compare</span> <a class="link" href="flat_multimap.html#idm45666073581840-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>
 158   <span class="identifier">value_compare</span> <a class="link" href="flat_multimap.html#idm45666073578848-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>
 159   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073575840-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>
 160   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073572384-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>
 161   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073568656-bb"><span class="identifier">find</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="special">;</span>
 162   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073563440-bb"><span class="identifier">find</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>
 163   <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073557952-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>
 164   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a class="link" href="flat_multimap.html#idm45666073554288-bb"><span class="identifier">count</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>
 165   <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073548864-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>
 166   <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_multimap.html#idm45666073545152-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>
 167   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073539680-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>
 168   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073536224-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>
 169   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073532496-bb"><span class="identifier">lower_bound</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="special">;</span>
 170   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073527280-bb"><span class="identifier">lower_bound</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>
 171   <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073521792-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>
 172   <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073518336-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>
 173   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="flat_multimap.html#idm45666073514608-bb"><span class="identifier">upper_bound</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="special">;</span>
 174   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="flat_multimap.html#idm45666073509392-bb"><span class="identifier">upper_bound</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>
 175   <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_multimap.html#idm45666073503904-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>
 176   <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>
 177   <a class="link" href="flat_multimap.html#idm45666073500464-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>
 178   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <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_multimap.html#idm45666073496736-bb"><span class="identifier">equal_range</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="special">;</span>
 179   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span>
 180     <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> <a class="link" href="flat_multimap.html#idm45666073491536-bb"><span class="identifier">equal_range</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>
 181   <span class="identifier">sequence_type</span> <a class="link" href="flat_multimap.html#idm45666073486048-bb"><span class="identifier">extract_sequence</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
 182   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073481568-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>
 183   <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073477184-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>
 184
 185   <span class="comment">// <a class="link" href="flat_multimap.html#idm45666073329760-bb">friend functions</a></span>
 186   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073329200-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 187   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073324208-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 188   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073319216-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 189   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073314224-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 190   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073309232-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 191   <span class="keyword">friend</span> <span class="keyword">bool</span> <a class="link" href="flat_multimap.html#idm45666073304224-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 192   <span class="keyword">friend</span> <span class="keyword">void</span> <a class="link" href="flat_multimap.html#idm45666073299216-bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 193 <span class="special">}</span><span class="special">;</span></pre></div>
 194 <div class="refsect1">
 195 <a name="id-1.3.10.14.8.4.4"></a><h2>Description</h2>
 196 <p>A <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys.</p>
 197 <p>A <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> satisfies all of the requirements of a container and of a reversible container and of an associative container. For a flat_multimap&lt;Key,T&gt; the key_type is Key and the value_type is std::pair&lt;Key,T&gt; (unlike std::multimap&lt;Key, T&gt; which value_type is std::pair&lt;<span class="bold"><strong>const</strong></span> Key, T&gt;).</p>
 198 <p><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> is similar to std::multimap 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>
 199 <p>Using vector-like sequence containers means that inserting a new element into a <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 200 <p>This container provides random-access iterators.</p>
 201 <p>
 202 </p>
 203 <div class="refsect2">
 204 <a name="id-1.3.10.14.8.4.4.8"></a><h3>Template Parameters</h3>
 205 <div class="orderedlist"><ol class="orderedlist" type="1">
 206 <li class="listitem">
 207 <pre class="literallayout"><span class="keyword">typename</span> Key</pre>
 208 <p>is the key_type of the map </p>
 209 </li>
 210 <li class="listitem"><pre class="literallayout"><span class="keyword">typename</span> T</pre></li>
 211 <li class="listitem">
 212 <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>
 213 <p>is the ordering function for Keys (e.g. <span class="emphasis"><em>std::less&lt;Key&gt;</em></span>). </p>
 214 </li>
 215 <li class="listitem">
 216 <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">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span></pre>
 217 <p>is either:</p>
 218 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 219 <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>
 220 <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>
 221 </ul></div>
 222 <p>
 223 </p>
 224 </li>
 225 </ol></div>
 226 </div>
 227 <div class="refsect2">
 228 <a name="id-1.3.10.14.8.4.4.9"></a><h3>
 229 <a name="boost.container.flat_multimapconstruct-copy-destruct"></a><code class="computeroutput">flat_multimap</code>
 230         public
 231        construct/copy/destruct</h3>
 232 <div class="orderedlist"><ol class="orderedlist" type="1">
 233 <li class="listitem">
 234 <pre class="literallayout"><a name="idm45666073470992-bb"></a><span class="identifier">flat_multimap</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>
 235 <p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty <code class="computeroutput"><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a></code>.</p>
 236 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 237 </li>
 238 <li class="listitem">
 239 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666073467728-bb"></a><span class="identifier">flat_multimap</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>
 240 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified allocator.</p>
 241 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 242 </li>
 243 <li class="listitem">
 244 <pre class="literallayout"><span class="keyword">explicit</span> <a name="idm45666073463904-bb"></a><span class="identifier">flat_multimap</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>
 245 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object .</p>
 246 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 247 </li>
 248 <li class="listitem">
 249 <pre class="literallayout"><a name="idm45666073460064-bb"></a><span class="identifier">flat_multimap</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>
 250 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object and allocator.</p>
 251 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 252 </li>
 253 <li class="listitem">
 254 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 255   <a name="idm45666073455808-bb"></a><span class="identifier">flat_multimap</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>
 256 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> and inserts elements from the range [first ,last ).</p>
 257 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 258 </li>
 259 <li class="listitem">
 260 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 261   <a name="idm45666073450592-bb"></a><span class="identifier">flat_multimap</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>
 262                 <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>
 263 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified allocator, and inserts elements from the range [first ,last ).</p>
 264 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 265 </li>
 266 <li class="listitem">
 267 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 268   <a name="idm45666073444656-bb"></a><span class="identifier">flat_multimap</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>
 269 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object and inserts elements from the range [first ,last ).</p>
 270 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 271 </li>
 272 <li class="listitem">
 273 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 274   <a name="idm45666073438704-bb"></a><span class="identifier">flat_multimap</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>
 275                 <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>
 276 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object and allocator, and inserts elements from the range [first ,last ).</p>
 277 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </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="idm45666073432048-bb"></a><span class="identifier">flat_multimap</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>
 282 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 283 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 284 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 285 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 286 </li>
 287 <li class="listitem">
 288 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 289   <a name="idm45666073424272-bb"></a><span class="identifier">flat_multimap</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>
 290                 <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>
 291 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 292 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 293 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 294 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 295 </li>
 296 <li class="listitem">
 297 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 298   <a name="idm45666073415776-bb"></a><span class="identifier">flat_multimap</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>
 299                 <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>
 300 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 301 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 302 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 303 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 304 </li>
 305 <li class="listitem">
 306 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 307   <a name="idm45666073406576-bb"></a><span class="identifier">flat_multimap</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>
 308                 <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>
 309 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 310 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 311 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 312 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 313 </li>
 314 <li class="listitem">
 315 <pre class="literallayout"><a name="idm45666073398080-bb"></a><span class="identifier">flat_multimap</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>
 316 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a></code> 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 the predicate and otherwise N logN, where N is last - first. </p>
 318 </li>
 319 <li class="listitem">
 320 <pre class="literallayout"><a name="idm45666073394368-bb"></a><span class="identifier">flat_multimap</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>
 321               <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>
 322 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a></code> using the specified allocator, and inserts elements from the range [il.begin(), il.end()).</p>
 323 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 324 </li>
 325 <li class="listitem">
 326 <pre class="literallayout"><a name="idm45666073389936-bb"></a><span class="identifier">flat_multimap</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>
 327 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a></code> using the specified comparison object and inserts elements from the range [il.begin(), il.end()).</p>
 328 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 329 </li>
 330 <li class="listitem">
 331 <pre class="literallayout"><a name="idm45666073385504-bb"></a><span class="identifier">flat_multimap</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>
 332               <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>
 333 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a></code> using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).</p>
 334 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
 335 </li>
 336 <li class="listitem">
 337 <pre class="literallayout"><a name="idm45666073380368-bb"></a><span class="identifier">flat_multimap</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>
 338 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 339 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 340 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 341 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 342 </li>
 343 <li class="listitem">
 344 <pre class="literallayout"><a name="idm45666073374112-bb"></a><span class="identifier">flat_multimap</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>
 345               <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>
 346 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 347 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 348 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 349 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 350 </li>
 351 <li class="listitem">
 352 <pre class="literallayout"><a name="idm45666073367120-bb"></a><span class="identifier">flat_multimap</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>
 353               <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>
 354 <p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified comparison object and allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
 355 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 356 <p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
 357 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 358 </li>
 359 <li class="listitem">
 360 <pre class="literallayout"><a name="idm45666073359424-bb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 361 <p><span class="bold"><strong>Effects</strong></span>: Copy constructs a <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code>.</p>
 362 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 363 </li>
 364 <li class="listitem">
 365 <pre class="literallayout"><a name="idm45666073355440-bb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 366 <p><span class="bold"><strong>Effects</strong></span>: Move constructs a <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code>. Constructs *this using x's resources.</p>
 367 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 368 <p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
 369 </li>
 370 <li class="listitem">
 371 <pre class="literallayout"><a name="idm45666073350416-bb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 372 <p><span class="bold"><strong>Effects</strong></span>: Copy constructs a <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified allocator.</p>
 373 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 374 </li>
 375 <li class="listitem">
 376 <pre class="literallayout"><a name="idm45666073345728-bb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 377 <p><span class="bold"><strong>Effects</strong></span>: Move constructs a <code class="computeroutput"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a></code> using the specified allocator. Constructs *this using x's resources.</p>
 378 <p><span class="bold"><strong>Complexity</strong></span>: Constant if a == x.get_allocator(), linear otherwise. </p>
 379 </li>
 380 <li class="listitem">
 381 <pre class="literallayout"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a name="idm45666073341120-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 382 <p><span class="bold"><strong>Effects</strong></span>: Makes *this a copy of x.</p>
 383 <p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
 384 </li>
 385 <li class="listitem">
 386 <pre class="literallayout"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span>
 387 <a name="idm45666073337280-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 388 <p><span class="bold"><strong>Effects</strong></span>: this-&gt;swap(x.get()).</p>
 389 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 390 </li>
 391 <li class="listitem">
 392 <pre class="literallayout"><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a name="idm45666073333168-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>
 393 <p><span class="bold"><strong>Effects</strong></span>: Assign content of il to *this</p>
 394 <p><span class="bold"><strong>Complexity</strong></span>: Linear in il.size(). </p>
 395 </li>
 396 </ol></div>
 397 </div>
 398 <div class="refsect2">
 399 <a name="id-1.3.10.14.8.4.4.10"></a><h3>
 400 <a name="idm45666073817648-bb"></a><code class="computeroutput">flat_multimap</code> public member functions</h3>
 401 <div class="orderedlist"><ol class="orderedlist" type="1">
 402 <li class="listitem"><pre class="literallayout"> <a name="idm45666073817088-bb"></a><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">value_type</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></li>
 403 <li class="listitem">
 404 <pre class="literallayout"><span class="identifier">allocator_type</span> <a name="idm45666073815664-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>
 405 <p><span class="bold"><strong>Effects</strong></span>: Returns a copy of the allocator that was passed to the object's constructor.</p>
 406 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 407 </li>
 408 <li class="listitem">
 409 <pre class="literallayout"><span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45666073812656-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>
 410 <p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
 411 <p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
 412 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 413 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 414 </li>
 415 <li class="listitem">
 416 <pre class="literallayout"><span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="idm45666073807968-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>
 417 <p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
 418 <p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
 419 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 420 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 421 </li>
 422 <li class="listitem">
 423 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073803264-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>
 424 <p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the first element contained in 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="idm45666073799424-bb"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
 430 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in 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">iterator</span> <a name="idm45666073795568-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>
 436 <p><span class="bold"><strong>Effects</strong></span>: Returns an 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">const_iterator</span> <a name="idm45666073791744-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>
 442 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the 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">reverse_iterator</span> <a name="idm45666073787920-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>
 448 <p><span class="bold"><strong>Effects</strong></span>: Returns a 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="idm45666073784064-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>
 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="idm45666073780208-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="idm45666073776352-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_iterator</span> <a name="idm45666073772496-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>
 472 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the 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="identifier">const_iterator</span> <a name="idm45666073768640-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>
 478 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</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">const_reverse_iterator</span> <a name="idm45666073764816-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>
 484 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed 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">const_reverse_iterator</span> <a name="idm45666073760960-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>
 490 <p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed 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="keyword">bool</span> <a name="idm45666073757104-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>
 496 <p><span class="bold"><strong>Effects</strong></span>: Returns true if the container contains no elements.</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="identifier">size_type</span> <a name="idm45666073753280-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>
 502 <p><span class="bold"><strong>Effects</strong></span>: Returns the number of the elements contained in the container.</p>
 503 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 504 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 505 </li>
 506 <li class="listitem">
 507 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073749440-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>
 508 <p><span class="bold"><strong>Effects</strong></span>: Returns the largest possible size of the container.</p>
 509 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 510 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 511 </li>
 512 <li class="listitem">
 513 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073745616-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>
 514 <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>
 515 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 516 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 517 </li>
 518 <li class="listitem">
 519 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073741728-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>
 520 <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>
 521 <p><span class="bold"><strong>Throws</strong></span>: If memory allocation allocation throws or T's copy constructor throws.</p>
 522 <p><span class="bold"><strong>Note</strong></span>: If capacity() is less than "cnt", iterators and references to to values might be invalidated. </p>
 523 </li>
 524 <li class="listitem">
 525 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073736640-bb"></a><span class="identifier">shrink_to_fit</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
 526 <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 T's copy constructor throws.</p>
 527 <p><span class="bold"><strong>Complexity</strong></span>: Linear to size(). </p>
 528 </li>
 529 <li class="listitem">
 530 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073733040-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>
 531 <p><span class="bold"><strong>Requires</strong></span>: size() &gt;= n.</p>
 532 <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>
 533 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 534 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 535 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 536 </li>
 537 <li class="listitem">
 538 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073726752-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>
 539 <p><span class="bold"><strong>Requires</strong></span>: size() &gt;= n.</p>
 540 <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>
 541 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 542 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 543 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 544 </li>
 545 <li class="listitem">
 546 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073720464-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>
 547 <p><span class="bold"><strong>Requires</strong></span>: begin() &lt;= p &lt;= end().</p>
 548 <p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and size() if p == end().</p>
 549 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 550 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 551 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 552 </li>
 553 <li class="listitem">
 554 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073714192-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>
 555 <p><span class="bold"><strong>Requires</strong></span>: begin() &lt;= p &lt;= end().</p>
 556 <p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and size() if p == end().</p>
 557 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 558 <p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
 559 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension </p>
 560 </li>
 561 <li class="listitem">
 562 <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="idm45666073707920-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>
 563 <p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... and returns the iterator pointing to the newly inserted element.</p>
 564 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 565 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 566 </li>
 567 <li class="listitem">
 568 <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>
 569   <span class="identifier">iterator</span> <a name="idm45666073702320-bb"></a><span class="identifier">emplace_hint</span><span class="special">(</span><span class="identifier">const_iterator</span> hint<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>
 570 <p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T 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>
 571 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 572 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
 573 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 574 </li>
 575 <li class="listitem">
 576 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073695056-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>
 577 <p><span class="bold"><strong>Effects</strong></span>: Inserts x and returns the iterator pointing to the newly inserted element.</p>
 578 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 579 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 580 </li>
 581 <li class="listitem">
 582 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073690656-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>
 583 <p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.</p>
 584 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 585 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 586 </li>
 587 <li class="listitem">
 588 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073686224-bb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">impl_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 589 <p><span class="bold"><strong>Effects</strong></span>: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.</p>
 590 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
 591 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 592 </li>
 593 <li class="listitem">
 594 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073681792-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>
 595 <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>
 596 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 597 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
 598 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 599 </li>
 600 <li class="listitem">
 601 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073675712-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>
 602 <p><span class="bold"><strong>Effects</strong></span>: Inserts a value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
 603 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 604 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
 605 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 606 </li>
 607 <li class="listitem">
 608 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073669616-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">impl_value_type</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
 609 <p><span class="bold"><strong>Effects</strong></span>: Inserts a value move constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
 610 <p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
 611 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
 612 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 613 </li>
 614 <li class="listitem">
 615 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 616   <span class="keyword">void</span> <a name="idm45666073663520-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>
 617 <p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
 618 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .</p>
 619 <p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
 620 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 621 </li>
 622 <li class="listitem">
 623 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span>
 624   <span class="keyword">void</span> <a name="idm45666073656816-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>
 625 <p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
 626 <p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
 627 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) if and only if there is no element with key equivalent to the key of that element. This function is more efficient than the normal range creation for ordered ranges.</p>
 628 <p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
 629 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements.</p>
 630 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 631 </li>
 632 <li class="listitem">
 633 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073647360-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>
 634 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()) .</p>
 635 <p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
 636 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
 637 </li>
 638 <li class="listitem">
 639 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073643040-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>
 640 <p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
 641 <p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()) if and only if there is no element with key equivalent to the key of that element. This function is more efficient than the normal range creation for ordered ranges.</p>
 642 <p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
 643 <p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements.</p>
 644 <p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
 645 </li>
 646 <li class="listitem">
 647 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 648   <span class="keyword">void</span> <a name="idm45666073635984-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 649 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 650 <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>
 651 <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>
 652 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 653 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 654 </li>
 655 <li class="listitem">
 656 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 657   <span class="keyword">void</span> <a name="idm45666073628496-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 658 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 659 <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>
 660 <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>
 661 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 662 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 663 </li>
 664 <li class="listitem">
 665 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 666   <span class="keyword">void</span> <a name="idm45666073621008-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 667 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 668 <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>
 669 <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>
 670 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 671 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 672 </li>
 673 <li class="listitem">
 674 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span>
 675   <span class="keyword">void</span> <a name="idm45666073613520-bb"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="flat_map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</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>
 676 <p><span class="bold"><strong>Requires</strong></span>: this-&gt;get_allocator() == source.get_allocator().</p>
 677 <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>
 678 <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>
 679 <p><span class="bold"><strong>Throws</strong></span>: Nothing unless the comparison object throws.</p>
 680 <p><span class="bold"><strong>Complexity</strong></span>: N log(size() + N) (N has the value source.size()) </p>
 681 </li>
 682 <li class="listitem">
 683 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073606032-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>
 684 <p><span class="bold"><strong>Effects</strong></span>: Erases the element pointed to by p.</p>
 685 <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>
 686 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the elements with keys bigger than p</p>
 687 <p><span class="bold"><strong>Note</strong></span>: Invalidates elements with keys not less than the erased element. </p>
 688 </li>
 689 <li class="listitem">
 690 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073600752-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>
 691 <p><span class="bold"><strong>Effects</strong></span>: Erases all elements in the container with key equivalent to x.</p>
 692 <p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements.</p>
 693 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
 694 </li>
 695 <li class="listitem">
 696 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073596400-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>
 697 <p><span class="bold"><strong>Effects</strong></span>: Erases all the elements in the range [first, last).</p>
 698 <p><span class="bold"><strong>Returns</strong></span>: Returns last.</p>
 699 <p><span class="bold"><strong>Complexity</strong></span>: size()*N where N is the distance from first to last.</p>
 700 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
 701 </li>
 702 <li class="listitem">
 703 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073590528-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</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>
 704 <p><span class="bold"><strong>Effects</strong></span>: Swaps the contents of *this and x.</p>
 705 <p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
 706 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 707 </li>
 708 <li class="listitem">
 709 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073585632-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>
 710 <p><span class="bold"><strong>Effects</strong></span>: erase(begin(),end()).</p>
 711 <p><span class="bold"><strong>Postcondition</strong></span>: size() == 0.</p>
 712 <p><span class="bold"><strong>Complexity</strong></span>: linear in size(). </p>
 713 </li>
 714 <li class="listitem">
 715 <pre class="literallayout"><span class="identifier">key_compare</span> <a name="idm45666073581840-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>
 716 <p><span class="bold"><strong>Effects</strong></span>: Returns the comparison object out of which a was constructed.</p>
 717 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 718 </li>
 719 <li class="listitem">
 720 <pre class="literallayout"><span class="identifier">value_compare</span> <a name="idm45666073578848-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>
 721 <p><span class="bold"><strong>Effects</strong></span>: Returns an object of value_compare constructed out of the comparison object.</p>
 722 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 723 </li>
 724 <li class="listitem">
 725 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073575840-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>
 726 <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>
 727 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 728 </li>
 729 <li class="listitem">
 730 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073572384-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>
 731 <p><span class="bold"><strong>Returns</strong></span>: An const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
 732 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 733 </li>
 734 <li class="listitem">
 735 <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="identifier">iterator</span> <a name="idm45666073568656-bb"></a><span class="identifier">find</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="special">;</span></pre>
 736 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 737 <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>
 738 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 739 </li>
 740 <li class="listitem">
 741 <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="identifier">const_iterator</span> <a name="idm45666073563440-bb"></a><span class="identifier">find</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>
 742 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 743 <p><span class="bold"><strong>Returns</strong></span>: An const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.</p>
 744 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
 745 </li>
 746 <li class="listitem">
 747 <pre class="literallayout"><span class="identifier">size_type</span> <a name="idm45666073557952-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>
 748 <p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
 749 <p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
 750 </li>
 751 <li class="listitem">
 752 <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="identifier">size_type</span> <a name="idm45666073554288-bb"></a><span class="identifier">count</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>
 753 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 754 <p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
 755 <p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
 756 </li>
 757 <li class="listitem">
 758 <pre class="literallayout"><span class="keyword">bool</span> <a name="idm45666073548864-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>
 759 <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>
 760 <p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
 761 </li>
 762 <li class="listitem">
 763 <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="idm45666073545152-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>
 764 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 765 <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>
 766 <p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
 767 </li>
 768 <li class="listitem">
 769 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073539680-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>
 770 <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>
 771 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 772 </li>
 773 <li class="listitem">
 774 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073536224-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>
 775 <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>
 776 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 777 </li>
 778 <li class="listitem">
 779 <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="identifier">iterator</span> <a name="idm45666073532496-bb"></a><span class="identifier">lower_bound</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="special">;</span></pre>
 780 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 781 <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>
 782 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 783 </li>
 784 <li class="listitem">
 785 <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="identifier">const_iterator</span> <a name="idm45666073527280-bb"></a><span class="identifier">lower_bound</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>
 786 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 787 <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>
 788 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 789 </li>
 790 <li class="listitem">
 791 <pre class="literallayout"><span class="identifier">iterator</span> <a name="idm45666073521792-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>
 792 <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>
 793 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 794 </li>
 795 <li class="listitem">
 796 <pre class="literallayout"><span class="identifier">const_iterator</span> <a name="idm45666073518336-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>
 797 <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>
 798 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 799 </li>
 800 <li class="listitem">
 801 <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="identifier">iterator</span> <a name="idm45666073514608-bb"></a><span class="identifier">upper_bound</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="special">;</span></pre>
 802 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 803 <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>
 804 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 805 </li>
 806 <li class="listitem">
 807 <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="identifier">const_iterator</span> <a name="idm45666073509392-bb"></a><span class="identifier">upper_bound</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>
 808 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 809 <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>
 810 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 811 </li>
 812 <li class="listitem">
 813 <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="idm45666073503904-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>
 814 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 815 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 816 </li>
 817 <li class="listitem">
 818 <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>
 819 <a name="idm45666073500464-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>
 820 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 821 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 822 </li>
 823 <li class="listitem">
 824 <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="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="idm45666073496736-bb"></a><span class="identifier">equal_range</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="special">;</span></pre>
 825 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 826 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 827 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 828 </li>
 829 <li class="listitem">
 830 <pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span>
 831   <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> <a name="idm45666073491536-bb"></a><span class="identifier">equal_range</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>
 832 <p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
 833 <p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
 834 <p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
 835 </li>
 836 <li class="listitem">
 837 <pre class="literallayout"><span class="identifier">sequence_type</span> <a name="idm45666073486048-bb"></a><span class="identifier">extract_sequence</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
 838 <p><span class="bold"><strong>Effects</strong></span>: Extracts the internal sequence container.</p>
 839 <p><span class="bold"><strong>Complexity</strong></span>: Same as the move constructor of sequence_type, usually constant.</p>
 840 <p><span class="bold"><strong>Postcondition</strong></span>: this-&gt;empty()</p>
 841 <p><span class="bold"><strong>Throws</strong></span>: If secuence_type's move constructor throws </p>
 842 </li>
 843 <li class="listitem">
 844 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073481568-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>
 845 <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>
 846 <p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()</p>
 847 <p><span class="bold"><strong>Throws</strong></span>: If the comparison or the move constructor throws </p>
 848 </li>
 849 <li class="listitem">
 850 <pre class="literallayout"><span class="keyword">void</span> <a name="idm45666073477184-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>
 851 <p><span class="bold"><strong>Requires</strong></span>: seq shall be ordered according to this-&gt;compare().</p>
 852 <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>
 853 <p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(1)</p>
 854 <p><span class="bold"><strong>Throws</strong></span>: If the move assignment throws </p>
 855 </li>
 856 </ol></div>
 857 </div>
 858 <div class="refsect2">
 859 <a name="id-1.3.10.14.8.4.4.11"></a><h3>
 860 <a name="idm45666073329760-bb"></a><code class="computeroutput">flat_multimap</code> friend functions</h3>
 861 <div class="orderedlist"><ol class="orderedlist" type="1">
 862 <li class="listitem">
 863 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073329200-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 864 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are equal</p>
 865 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 866 </li>
 867 <li class="listitem">
 868 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073324208-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 869 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are unequal</p>
 870 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 871 </li>
 872 <li class="listitem">
 873 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073319216-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 874 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is less than y</p>
 875 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 876 </li>
 877 <li class="listitem">
 878 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073314224-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 879 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is greater than y</p>
 880 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 881 </li>
 882 <li class="listitem">
 883 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073309232-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 884 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or less than y</p>
 885 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 886 </li>
 887 <li class="listitem">
 888 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">bool</span> <a name="idm45666073304224-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_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 889 <p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or greater than y</p>
 890 <p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
 891 </li>
 892 <li class="listitem">
 893 <pre class="literallayout"><span class="keyword">friend</span> <span class="keyword">void</span> <a name="idm45666073299216-bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <a class="link" href="flat_multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
 894 <p><span class="bold"><strong>Effects</strong></span>: x.swap(y)</p>
 895 <p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
 896 </li>
 897 </ol></div>
 898 </div>
 899 </div>
 900 </div>
 901 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 902 <td align="left"></td>
 903 <td align="right"><div class="copyright-footer">Copyright &#169; 2009-2018 Ion Gaztanaga<p>
 904         Distributed under the Boost Software License, Version 1.0. (See accompanying
 905         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>)
 906       </p>
 907 </div></td>
 908 </tr></table>
 909 <hr>
 910 <div class="spirit-nav">
 911 <a accesskey="p" href="flat_map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#header.boost.container.flat_map_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="pmr/flat_map_of.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
 912 </div>
 913 </body>
 914 </html>