Squashed 'third_party/boostorg/multi_index/' content from commit d95a949
Change-Id: Ie67c2d797c11dc122c7f11e767e81691bf2191a4
git-subtree-dir: third_party/boostorg/multi_index
git-subtree-split: d95a94942b918140e565feb99ed36ea97c30084e
diff --git a/doc/reference/hash_indices.html b/doc/reference/hash_indices.html
new file mode 100644
index 0000000..2098932
--- /dev/null
+++ b/doc/reference/hash_indices.html
@@ -0,0 +1,1159 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Hashed indices reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="ord_indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="seq_indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Hashed indices reference</h1>
+
+<div class="prev_link"><a href="rnk_indices.html"><img src="../prev.gif" alt="ranked indices" border="0"><br>
+Ranked indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="seq_indices.html"><img src="../next.gif" alt="sequenced indices" border="0"><br>
+Sequenced indices
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#hash_index_fwd_synopsis">Header
+ <code>"boost/multi_index/hashed_index_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/hashed_index.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#unique_non_unique">
+ Index specifiers <code>hashed_unique</code> and <code>hashed_non_unique</code>
+ </a></li>
+ <li><a href="#hash_indices">Hashed indices</a>
+ <ul>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#types">Nested types</a></li>
+ <li><a href="#constructors">Constructors, copy and assignment</a></li>
+ <li><a href="#iterators">Iterators</a></li>
+ <li><a href="#modifiers">Modifiers</a></li>
+ <li><a href="#observers">Observers</a></li>
+ <li><a href="#lookup">Lookup</a></li>
+ <li><a href="#bucket_interface">Bucket interface</a></li>
+ <li><a href="#hash_policy">Hash policy</a></li>
+ <li><a href="#comparison">Comparison</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="hash_index_fwd_synopsis">Header
+<a href="../../../../boost/multi_index/hashed_index_fwd.hpp">
+<code>"boost/multi_index/hashed_index_fwd.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers hashed_unique and hashed_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult hashed_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hashed_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult hashed_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hashed_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index name is implementation defined</b><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>hashed_index_fwd.hpp</code> provides forward declarations for index specifiers
+<a href="#unique_non_unique"><code>hashed_unique</code> and <code>hashed_non_unique</code></a> and
+their associated <a href="#hash_indices">hashed index</a> classes.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index/hashed_index.hpp">
+<code>"boost/multi_index/hashed_index.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers hashed_unique and hashed_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult hashed_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hashed_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult hashed_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hashed_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,!=</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="unique_non_unique">
+Index specifiers <code>hashed_unique</code> and <code>hashed_non_unique</code>
+</a></h3>
+
+<p>
+These <a href="indices.html#index_specification">index specifiers</a> allow
+for insertion of <a href="#hash_indices">hashed indices</a> without and with
+allowance of duplicate elements, respectively. The syntax of <code>hashed_unique</code>
+and <code>hashed_non_unique</code> coincide, thus we describe them in a grouped manner.
+<code>hashed_unique</code> and <code>hashed_non_unique</code> can be instantiated in
+two different forms, according to whether a tag list for the index is provided or not:
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>=</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>hash</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal_to</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>hashed_unique</span> <span class=special>|</span> <span class=identifier>hashed_non_unique</span><span class=special>)</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>=</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>hash</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal_to</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>hashed_unique</span> <span class=special>|</span> <span class=identifier>hashed_non_unique</span><span class=special>)</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>
+If provided, <code>TagList</code> must be an instantiation of the class template
+<a href="indices.html#tag"><code>tag</code></a>.
+The template arguments are used by the corresponding index implementation,
+refer to the <a href="#hash_indices">hashed indices</a> reference section for further
+explanations on their acceptable type values.
+</p>
+
+<h3><a name="hash_indices">Hashed indices</a></h3>
+
+<p>
+A hashed index provides fast retrieval of elements of a <code>multi_index_container</code>
+through hashing techniques.
+A hashed index is particularized according to a given
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+that retrieves keys from elements of <code>multi_index_container</code>, a <code>Hash</code>
+function object which returns hash values for the keys and a binary predicate <code>Pred</code>
+acting as an equivalence relation on values of <code>Key</code>.
+</p>
+
+<p>
+There are two variants of hashed indices: <i>unique</i>, which do
+not allow duplicate elements (with respect to its associated equality
+predicate) and <i>non-unique</i>, which accept those duplicates.
+The interface of these two variants is the same, so they are documented
+together, with minor differences explicitly stated when they exist.
+</p>
+
+<p>
+Except where noted or if the corresponding interface does not exist, hashed indices
+(both unique and non-unique) satisfy the C++ requirements for unordered associative
+containers at <b>[unord.req]</b> (supporting unique and equivalent keys, respectively.)
+Validity of iterators and references to
+elements is preserved in all cases. Occasionally, the exception safety guarantees provided
+are actually stronger than required by the standard. We only provide descriptions of
+those types and operations that do not exactly conform to or are not mandated by the standard
+requirements.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined: dependent on types Value, Allocator,
+ TagList, KeyFromValue, Hash, Pred</b><span class=special>></span>
+<span class=keyword>class</span> <b>name is implementation defined</b>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span> <span class=identifier>key_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>KeyFromValue</span> <span class=identifier>key_from_value</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Hash</span> <span class=identifier>hasher</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Pred</span> <span class=identifier>key_equal</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span>
+ <span class=identifier>size_type</span><span class=special>,</span><span class=identifier>key_from_value</span><span class=special>,</span><span class=identifier>hasher</span><span class=special>,</span><span class=identifier>key_equal</span><span class=special>></span> <span class=identifier>ctor_args</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>TagList</span> <span class=identifier>tag_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>pointer</span> <span class=identifier>pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_pointer</span> <span class=identifier>const_pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>reference</span> <span class=identifier>reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_reference</span> <span class=identifier>const_reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>size_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>difference_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>const_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>local_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>const_local_iterator</span><span class=special>;</span>
+
+ <span class=comment>// construct/destroy/copy:</span>
+
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// size and capacity:</span>
+
+ <span class=keyword>bool</span> <span class=identifier>empty</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// iterators:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cbegin</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cend</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// modifiers:</span>
+
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>emplace_hint</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <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><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>);</span>
+ <span class=identifier>size_type</span> <span class=identifier>erase</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>clear</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=comment>// observers:</span>
+
+ <span class=identifier>key_from_value</span> <span class=identifier>key_extractor</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>hasher</span> <span class=identifier>hash_function</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_equal</span> <span class=identifier>key_eq</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// lookup:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleHash</span><span class=special>,</span> <span class=keyword>typename</span> <span class=identifier>CompatiblePred</span>
+ <span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleHash</span><span class=special>&</span> <span class=identifier>hash</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatiblePred</span><span class=special>&</span> <span class=identifier>eq</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleHash</span><span class=special>,</span> <span class=keyword>typename</span> <span class=identifier>CompatiblePred</span>
+ <span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleHash</span><span class=special>&</span> <span class=identifier>hash</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatiblePred</span><span class=special>&</span> <span class=identifier>eq</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleHash</span><span class=special>,</span> <span class=keyword>typename</span> <span class=identifier>CompatiblePred</span>
+ <span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,
+ </span><span class=keyword>const</span> <span class=identifier>CompatibleHash</span><span class=special>&</span> <span class=identifier>hash</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatiblePred</span><span class=special>&</span> <span class=identifier>eq</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// bucket interface:</span>
+
+ <span class=identifier>size_type</span> <span class=identifier>bucket_count</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_bucket_count</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>bucket_size</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>bucket</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_type</span><span class=special>&</span> <span class=identifier>k</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>local_iterator</span> <span class=identifier>begin</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+ <span class=identifier>const_local_iterator</span> <span class=identifier>begin</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>local_iterator</span> <span class=identifier>end</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+ <span class=identifier>const_local_iterator</span> <span class=identifier>end</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_local_iterator</span> <span class=identifier>cbegin</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_local_iterator</span> <span class=identifier>cend</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>local_iterator</span> <span class=identifier>local_iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_local_iterator</span> <span class=identifier>local_iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// hash policy:</span>
+
+ <span class=keyword>float</span> <span class=identifier>load_factor</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>float</span> <span class=identifier>max_load_factor</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>void</span> <span class=identifier>max_load_factor</span><span class=special>(</span><span class=keyword>float</span> <span class=identifier>z</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>rehash</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>reserve</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+<span class=special>};</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>==(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>!=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>==</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity_signature">Complexity signature</a></h4>
+
+<p>
+Here and in the descriptions of operations of hashed indices, we adopt the
+scheme outlined in the
+<a href="indices.html#complexity_signature">complexity signature
+section</a>. The complexity signature of hashed indices is:
+<ul>
+ <li>copying: <code>c(n)=n*log(n)</code>,</li>
+ <li>insertion: average case <code>i(n)=1</code> (amortized constant),
+ worst case <code>i(n)=n<sub>dist</sub></code>,</li>
+ <li>hinted insertion: average case <code>h(n)=1</code> (amortized constant),
+ worst case <code>h(n)=n<sub>dist</sub></code>,</li>
+ <li>deletion: <code>d(n)=1</code> (constant),</li>
+ <li>replacement:
+ <ul>
+ <li>if the new element key is equivalent to the original, <code>r(n)=1</code> (constant),</li>
+ <li>otherwise, average case <code>r(n)=1</code> (constant),
+ worst case <code>r(n)=n<sub>dist</sub></code>,</li>
+ </ul></li>
+ <li>modifying: average case <code>m(n)=1</code> (constant),
+ worst case <code>m(n)=n<sub>dist</sub></code>,</li>
+</ul>
+where <code>n<sub>dist</sub></code> is the number of non-equivalent elements out of
+the total <code>n</code>.
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>Hashed indices are instantiated internally to <code>multi_index_container</code> and
+specified by means of <a href="indices.html#indexed_by"><code>indexed_by</code></a>
+with <a href="#unique_non_unique"> index specifiers <code>hashed_unique</code>
+and <code>hashed_non_unique</code></a>. Instantiations are dependent on the
+following types:
+<ul>
+ <li><code>Value</code> from <code>multi_index_container</code>,</li>
+ <li><code>Allocator</code> from <code>multi_index_container</code>,</li>
+ <li><code>TagList</code> from the index specifier (if provided, otherwise <code>tag<></code> is assumed),</li>
+ <li><code>KeyFromValue</code> from the index specifier,</li>
+ <li><code>Hash</code> from the index specifier,</li>
+ <li><code>Pred</code> from the index specifier.</li>
+</ul>
+<code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>. The type <code>KeyFromValue</code>,
+which determines the mechanism for extracting a key from <code>Value</code>,
+must be a model of <a href="key_extraction.html#key_extractors">
+<code>Key Extractor</code></a> from <code>Value</code>. <code>Hash</code> is a
+<code>CopyConstructible</code>unary function object
+taking a single argument of type <code>KeyFromValue::result_type</code> and returning a
+value of type <code>std::size_t</code> in the range
+<code>[0, std::numeric_limits<std::size_t>::max())</code>.
+<code>Pred</code> is a <code>CopyConstructible</code> binary predicate inducing an equivalence relation
+on elements of <code>KeyFromValue::result_type</code>. It is required that
+the <code>Hash</code> object return the same value for keys
+equivalent under <code>Pred</code>.
+</p>
+
+<h4><a name="types">Nested types</a></h4>
+
+<code>ctor_args</code>
+
+<blockquote>
+The first element of this tuple indicates the minimum number of buckets
+set up by the index on construction time. If the default value 0 is used,
+an implementation defined number is used instead.
+</blockquote>
+
+<code>iterator<br>
+const_iterator<br>
+local_iterator<br>
+const_local_iterator</code>
+
+<blockquote>
+These types are forward iterators.
+</blockquote>
+
+<h4><a name="constructors">Constructors, copy and assignment</a></h4>
+
+<p>
+As explained in the <a href="indices.html#index_concepts">index
+concepts section</a>, indices do not have public constructors or destructors.
+Assignment, on the other hand, is provided. Upon construction,
+<code>max_load_factor()</code> is 1.0.
+</p>
+
+<code><b>index class name</b>& operator=(const <b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>b</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> and <code>b</code> are the <code>multi_index_container</code>
+objects to which <code>*this</code> and <code>x</code> belong, respectively.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code><b>index class name</b>& operator=(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>list</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> is the <code>multi_index_container</code>
+object to which <code>*this</code> belongs.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<h4><a name="iterators">Iterators</a></h4>
+
+<code>iterator iterator_to(const value_type& x);<br>
+const_iterator iterator_to(const value_type& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>x</code> is a reference to an element of the container.<br>
+<b>Returns:</b> An iterator to <code>x</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<h4><a name="modifiers">Modifiers</a></h4>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace(Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong, except that rehashing may occur even if the operation fails.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+iterator emplace_hint(iterator position, Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<code>position</code> is used as a hint to improve the efficiency of the
+operation.<br>
+<b>Returns:</b> On successful insertion, an iterator to the newly inserted
+element. Otherwise, an iterator to an element that caused the insertion to be
+banned. Note that more than one element can be causing insertion not to be
+allowed.<br>
+<b>Complexity:</b> <code>O(H(n))</code>.<br>
+<b>Exception safety:</b> Strong, except that rehashing may occur even if the operation fails.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> insert(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> insert(value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Effects:</b> Inserts <code>x</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong, except that rehashing may occur even if the operation fails.<br>
+</blockquote>
+
+<code>iterator insert(iterator position,const value_type& x);</code><br>
+<code>iterator insert(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts <code>x</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<code>position</code> is used as a hint to improve the efficiency of the
+operation.<br>
+<b>Returns:</b> On successful insertion, an iterator to the newly inserted
+element. Otherwise, an iterator to an element that caused the insertion to be
+banned. Note that more than one element can be causing insertion not to be
+allowed.<br>
+<b>Complexity:</b> <code>O(H(n))</code>.<br>
+<b>Exception safety:</b> Strong, except that rehashing may occur even if the operation fails.<br>
+</blockquote>
+
+<code>template<typename InputIterator><br>
+void insert(InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>InputIterator</code> is an input iterator.
+<code>value_type</code> is
+<code>EmplaceConstructible</code> into
+<code>multi_index_container</code> from <code>*first</code>.
+<code>first</code> and <code>last</code> are not iterators into any
+index of the <code>multi_index_container</code> to which this index belongs.
+<code>last</code> is reachable from <code>first</code>.<br>
+<b>Effects:</b>
+For each element of [<code>first</code>, <code>last</code>), in this
+order, inserts it into the <code>multi_index_container</code>
+to which this index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Complexity:</b> <code>O(m*I(n+m))</code>, where
+<code>m</code> is the number of elements in [<code>first</code>,
+<code>last</code>).<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>void insert(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>())</span><span class=special>;</span>
+</pre></blockquote>
+</blockquote>
+
+<code>iterator erase(iterator position);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid dereferenceable iterator
+of the index.<br>
+<b>Effects:</b> Deletes the element pointed to by <code>position</code>.<br>
+<b>Returns:</b> An iterator pointing to the element immediately following
+the one that was deleted, or <code>end()</code>
+if no such element exists.<br>
+<b>Complexity:</b> <code>O(D(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>size_type erase(const key_type& x);</code>
+
+<blockquote>
+<b>Effects:</b> Deletes the elements with key equivalent to <code>x</code>.<br>
+<b>Returns:</b> Number of elements deleted.<br>
+<b>Complexity:</b> Average case, <code>O(1 + m*D(n))</code>, worst case
+<code>O(n<sub>dist</sub> + m*D(n))</code>, where <code>m</code> is
+the number of elements deleted.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>iterator erase(iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> [<code>first</code>,<code>last</code>) is a valid
+range of the index.<br>
+<b>Effects:</b> Deletes the elements in [<code>first</code>,<code>last</code>).<br>
+<b>Returns:</b> <code>last</code>.<br>
+<b>Complexity:</b> <code>O(m*D(n))</code>, where <code>m</code> is
+the number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="replace"><code>bool replace(iterator position,const value_type& x);</code></a><br>
+<code>bool replace(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Assigns the value <code>x</code> to the element pointed
+to by <code>position</code> into the <code>multi_index_container</code> to which
+the index belongs if, for the value <code>x</code>
+<ul>
+ <li>the index is non-unique OR no other element exists
+ (except possibly <code>*position</code>) with equivalent key,</li>
+ <li>AND replacing is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved
+in all cases. If the key of the new value is equivalent to that of the replaced value,
+the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the replacement took place,
+<code>false</code> otherwise.<br>
+<b>Complexity:</b> <code>O(R(n))</code>.<br>
+<b>Exception safety:</b> Strong. If an exception is thrown by some
+user-provided operation the <code>multi_index_container</code> to which the index
+belongs remains in its original state.
+</blockquote>
+
+<a name="modify">
+<code>template<typename Modifier> bool modify(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> is a unary function object
+accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and rearranges <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement is successful if
+<ul>
+ <li>the index is non-unique OR no other element exists
+ with equivalent key,</li>
+ <li>AND rearrangement is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+If the rearrangement fails, the element is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved if the
+operation succeeds. If the key of the modified value is equivalent to that of the
+original value, the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Basic. If an exception is thrown by some
+user-provided operation (including <code>mod</code>), then
+the element pointed to by <code>position</code> is erased.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> and <code>back</code> are unary function
+objects accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(e)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and tries to rearrange <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement is successful if
+<ul>
+ <li>the index is non-unique OR no other element exists
+ with equivalent key,</li>
+ <li>AND rearrangement is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+If the rearrangement fails, <code>back(e)</code> is invoked: if the resulting value
+of <code>e</code> is consistent with its original position and constraints in all
+indices, the element is kept, otherwise it is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved except if
+the element is erased under the conditions described below.
+If the key of the modified value is equivalent to that of the
+original value, the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Strong, except if <code>mod</code> or <code>back</code> throw an
+exception or <code>back(e)</code> fails to properly restore the element or there is
+a throwing user-provided operation after invoking <code>back(e)</code>, in which cases
+the modified element is erased. If <code>back</code>
+throws inside the handling code executing after some other user-provided
+operation has thrown, it is the exception generated by <code>back</code> that
+is rethrown.
+</blockquote>
+
+<a name="modify_key">
+<code>template<typename Modifier> bool modify_key(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>key_from_value</code> is a read/write
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+from <code>value_type</code>. <code>mod</code> is a
+unary function object accepting arguments of type
+<code>key_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(k)</code>, where <code>k</code> is the key of the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>k</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Equivalent to <code>modify(position,mod')</code>,
+with <code>mod'</code> defined in such a way that
+<code>mod'(x)</code> is the same as <code>mod(key(x))</code>, where
+<code>key</code> is the internal <code>KeyFromValue</code> object of the index.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify_key(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>key_from_value</code> is a read/write
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+from <code>value_type</code>. <code>mod</code> and <code>back</code>
+are unary function objects accepting arguments of type
+<code>key_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(k)</code>, where <code>k</code> is the key of the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>k</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(k)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Equivalent to <code>modify(position,mod',back')</code>,
+with <code>mod'</code> and <code>back</code> defined in such a way that
+<code>mod'(x)</code> is the same as <code>mod(key(x))</code> and
+<code>back'(x)</code> is the same as <code>back(key(x))</code>, where
+<code>key</code> is the internal <code>KeyFromValue</code> object of the index.
+</blockquote>
+
+<h4><a name="observers">Observers</a></h4>
+
+<p>Apart from standard <code>hash_function</code> and <code>key_eq</code>,
+hashed indices have a member function for retrieving the internal key extractor
+used.
+</p>
+
+<code>key_from_value key_extractor()const;</code>
+
+<blockquote>
+Returns a copy of the <code>key_from_value</code> object used to construct
+the index.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<h4><a name="lookup">Lookup</a></h4>
+
+<p>
+Hashed indices provide the full lookup functionality required by
+<b>[unord.req]</b>, namely <code>find</code>,
+<code>count</code>, and <code>equal_range</code>. Additionally,
+these member functions are templatized to allow for non-standard
+arguments, so extending the types of search operations allowed.
+The kind of arguments permissible when invoking the lookup member
+functions is defined by the following concept.
+</p>
+
+<p>
+Consider a pair (<code>Hash</code>, <code>Pred</code>) where
+<code>Hash</code> is a hash functor over values of type <code>Key</code>
+and <code>Pred</code> is a binary predicate
+inducing an equivalence relation
+on <code>Key</code>, with the additional constraint that equivalent
+keys have the same hash value.
+A triplet of types (<code>CompatibleKey</code>, <code>CompatibleHash</code>,
+<code>CompatiblePred</code>) is said to be a <i>compatible extension</i>
+of (<code>Hash</code>, <code>Pred</code>) if
+<ol>
+ <li><code>CompatibleHash</code> is a hash functor on values of
+ type <code>CompatibleKey</code>,</li>
+ <li><code>CompatiblePred</code> is a binary predicate over (<code>Key</code>,
+ <code>CompatibleKey</code>),</li>
+ <li><code>CompatiblePred</code> is a binary predicate over (<code>CompatibleKey</code>,
+ <code>Key</code>),</li>
+ <li>if <code>c_eq(ck,k1)</code> then <code>c_eq(k1,ck)</code>,</li>
+ <li>if <code>c_eq(ck,k1)</code> and <code>eq(k1,k2)</code> then
+ <code>c_eq(ck,k2)</code>,</li>
+ <li>if <code>c_eq(ck,k1)</code> and <code>c_eq(ck,k2)</code> then
+ <code>eq(k1,k2)</code>,</li>
+ <li>if <code>c_eq(ck,k1)</code> then <code>c_hash(ck)==hash(k1)</code>,</li>
+</ol>
+for every <code>c_hash</code> of type <code>CompatibleHash</code>,
+<code>c_eq</code> of type <code>CompatiblePred</code>,
+<code>hash</code> of type <code>Hash</code>,
+<code>eq</code> of type <code>Pred</code>, <code>ck</code> of type
+<code>CompatibleKey</code> and <code>k1</code>, <code>k2</code> of type
+<code>Key</code>.
+</p>
+
+<p>Additionally, a type <code>CompatibleKey</code> is said to be a
+<i>compatible key</i> of (<code>Hash</code>, <code>Pred</code>) if
+(<code>CompatibleKey</code>, <code>Hash</code>, <code>Pred</code>)
+is a compatible extension of (<code>Hash</code>, <code>Pred</code>).
+This implies that <code>Hash</code> and <code>Pred</code> accept arguments
+of type <code>CompatibleKey</code>, which usually means they have
+several overloads of their corresponding <code>operator()</code>
+member functions.
+</p>
+
+<p>
+In the context of a compatible extension or a compatible key, the expression
+"equivalent key" takes on its obvious interpretation.
+</p>
+
+<code>template<typename CompatibleKey> iterator find(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns a pointer to an element whose key is equivalent to
+<code>x</code>, or <code>end()</code> if such an element does not exist.<br>
+<b>Complexity:</b> Average case <code>O(1)</code> (constant), worst case
+<code>O(n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<code>template<<br>
+ typename CompatibleKey,typename CompatibleHash, typename CompatiblePred<br>
+><br>
+iterator find(<br>
+ const CompatibleKey& x,<br>
+ const CompatibleHash& hash,const CompatiblePred& eq)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleHash</code>,
+<code>CompatiblePred</code>) is a compatible extension of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns a pointer to an element whose key is equivalent to
+<code>x</code>, or <code>end()</code> if such an element does not exist.<br>
+<b>Complexity:</b> Average case <code>O(1)</code> (constant), worst case
+<code>O(n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+size_type count(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns the number of elements with key equivalent to <code>x</code>.<br>
+<b>Complexity:</b> Average case <code>O(count(x))</code>, worst case
+<code>O(count(x)+n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<code>template<<br>
+ typename CompatibleKey,typename CompatibleHash, typename CompatiblePred<br>
+><br>
+size_type count(<br>
+ const CompatibleKey& x,<br>
+ const CompatibleHash& hash,const CompatiblePred& eq)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleHash</code>,
+<code>CompatiblePred</code>) is a compatible extension of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns the number of elements with key equivalent to <code>x</code>.<br>
+<b>Complexity:</b> Average case <code>O(count(x,hash,eq))</code>, worst case
+<code>O(count(x,hash,eq)+n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+std::pair<iterator,iterator> equal_range(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns a range containing all elements with keys equivalent
+to <code>x</code> (and only those), or (<code>end()</code>,<code>end()</code>)
+if no such elements exist.<br>
+<b>Complexity:</b> Average case <code>O(1)</code> (constant), worst case
+<code>O(n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<code>template<<br>
+ typename CompatibleKey,typename CompatibleHash, typename CompatiblePred<br>
+><br>
+std::pair<iterator,iterator> equal_range(<br>
+ const CompatibleKey& x,<br>
+ const CompatibleHash& hash,const CompatiblePred& eq)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleHash</code>,
+<code>CompatiblePred</code>) is a compatible extension of
+(<code>hasher</code>, <code>key_equal</code>).<br>
+<b>Effects:</b> Returns a range containing all elements with keys equivalent
+to <code>x</code> (and only those), or (<code>end()</code>,<code>end()</code>)
+if no such elements exist.<br>
+<b>Complexity:</b> Average case <code>O(1)</code> (constant), worst case
+<code>O(n<sub>dist</sub>)</code>.<br>
+</blockquote>
+
+<h4><a name="bucket_interface">Bucket interface</a></h4>
+
+<code>local_iterator local_iterator_to(const value_type& x);<br>
+const_local_iterator local_iterator_to(const value_type& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>x</code> is a reference to an element of the container.<br>
+<b>Returns:</b> An iterator to <code>x</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+
+<h4><a name="hash_policy">Hash policy</a></h4>
+
+<code>void rehash(size_type n);</code>
+
+<blockquote>
+<b>Effects:</b> Increases if necessary the number of internal buckets
+so that <code>size()/bucket_count()</code> does not exceed the maximum
+load factor, and <code>bucket_count()>=n</code>.<br>
+<b>Postconditions:</b> Validity of iterators and references to the
+elements contained is preserved.<br>
+<b>Complexity:</b> <code>O(m)</code>, where <code>m</code> is the number of
+non-equivalent elements in the index.<br>
+<b>Exception safety:</b> Strong.
+</blockquote>
+
+<code>void reserve(size_type n);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>rehash</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>ceil</span><span class=special>(</span><span class=identifier>n</span><span class=special>/</span><span class=identifier>max_load_factor</span><span class=special>()));</span>
+</pre></blockquote>
+</blockquote>
+
+<h4><a name="comparison">Comparison</a></h4>
+
+<code>template<<i>implementation defined</i>><br>
+bool operator==(const <i>index class name</i>& x,const <i>index class name</i>& y);</code>
+
+<blockquote>
+<b>Requires:</b> <code>x.key_extractor()</code>, <code>x.hash_function()</code> and
+<code>x.key_eq()</code> have the same behavior as the corresponding objects in <code>y</code>.
+For any two elements <code>e1</code>, <code>e2</code> in <code>x</code> or <code>y</code>,
+if <code>e1==e2</code> then their keys are equivalent.<br>
+<b>Returns:</b> <code>true</code> iff <code>x</code> and <code>y</code> have the same size
+and for each key <code>k</code> present in <code>x</code> the range
+<code>x.equal_range(k)</code> is equal (considering the <code>==</code> operator of <code>value_type</code>)
+to <code>y.equal_range(k)</code> under permutations of the elements.<br>
+<b>Complexity:</b> Let <code>k<sub>1</sub></code>,...,<code>k<sub>m</sub></code> be the different
+keys present in <code>x</code>:<br>
+<ul>
+ <li>If, for each <code>k<sub>i</sub></code>, <code>x.equal_range(k<sub>i</sub>)</code> is arranged
+ in the same order as <code>y.equal_range(k<sub>i</sub>)</code>, average case is
+ <code>O(x.size())</code>, worst case <code>O(x.size()<sup>2</sup>)</code>.
+ </li>
+ <li>Otherwise, average case is
+ <code>O(<font style="font-size:1.5em">Σ</font>(x.count(k<sub>i</sub>)<sup>2</sup>))</code>,
+ worst case <code>O(x.size()<sup>2</sup>)</code>.
+ </li>
+</ul>
+(For unique indices, the formulas above reduce to average case
+<code>O(x.size())</code>, worst case <code>O(x.size()<sup>2</sup>)</code>.)
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+Indices cannot be serialized on their own, but only as part of the
+<code>multi_index_container</code> into which they are embedded. In describing
+the additional preconditions and guarantees associated to hashed indices
+with respect to serialization of their embedding containers, we
+use the concepts defined in the <code>multi_index_container</code>
+<a href="multi_index_container.html#serialization">serialization section</a>.
+</p>
+
+Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
+output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.
+</blockquote>
+
+Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
+input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> Additionally to the general requirements, <code>key_eq()</code>
+must be serialization-compatible with <code>m.get<i>().key_eq()</code>,
+where <code>i</code> is the position of the hashed index in the container.<br>
+<b>Postconditions:</b> On successful loading, the range
+[<code>begin()</code>, <code>end()</code>) contains restored copies of every
+element in [<code>m.get<i>().begin()</code>, <code>m.get<i>().end()</code>),
+though not necessarily in the same order.
+</blockquote>
+
+Operation: saving of an <code>iterator</code> or <code>const_iterator</code>
+<code>it</code> to an output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>it</code> is a valid iterator of the index. The associated
+<code>multi_index_container</code> has been previously saved.
+</blockquote>
+
+Operation: loading of an <code>iterator</code> or <code>const_iterator</code>
+<code>it'</code> from an input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Postconditions:</b> On successful loading, if <code>it</code> was dereferenceable
+then <code>*it'</code> is the restored copy of <code>*it</code>, otherwise
+<code>it'==end()</code>.<br>
+<b>Note:</b> It is allowed that <code>it</code> be a <code>const_iterator</code>
+and the restored <code>it'</code> an <code>iterator</code>, or vice versa.
+</blockquote>
+
+Operation: saving of a <code>local_iterator</code> or
+<code>const_local_iterator</code>
+<code>it</code> to an output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>it</code> is a valid local iterator of the index. The
+associated <code>multi_index_container</code> has been previously saved.
+</blockquote>
+
+Operation: loading of a <code>local_iterator</code> or
+<code>const_local_iterator</code>
+<code>it'</code> from an input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Postconditions:</b> On successful loading, if <code>it</code> was dereferenceable
+then <code>*it'</code> is the restored copy of <code>*it</code>; if <code>it</code>
+was <code>m.get<i>().end(n)</code> for some <code>n</code>, then
+<code>it'==m'.get<i>().end(n)</code> (where <code>m</code> is the original
+<code>multi_index_container</code>, <code>m'</code> its restored copy
+and <code>i</code> is the ordinal of the index.)<br>
+<b>Note:</b> It is allowed that <code>it</code> be a <code>const_local_iterator</code>
+and the restored <code>it'</code> a <code>local_iterator</code>, or vice versa.
+</blockquote>
+
+<hr>
+
+<div class="prev_link"><a href="rnk_indices.html"><img src="../prev.gif" alt="ranked indices" border="0"><br>
+Ranked indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="seq_indices.html"><img src="../next.gif" alt="sequenced indices" border="0"><br>
+Sequenced indices
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised August 25th 2017</p>
+
+<p>© Copyright 2003-2017 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/index.html b/doc/reference/index.html
new file mode 100644
index 0000000..ddd2ece
--- /dev/null
+++ b/doc/reference/index.html
@@ -0,0 +1,148 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="../tutorial/techniques.html">
+<link rel="up" href="../index.html">
+<link rel="next" href="multi_index_container.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Reference</h1>
+
+<div class="prev_link"><a href="../tutorial/techniques.html"><img src="../prev.gif" alt="techniques" border="0"><br>
+Techniques
+</a></div>
+<div class="up_link"><a href="../index.html"><img src="../up.gif" alt="index" border="0"><br>
+Index
+</a></div>
+<div class="next_link"><a href="multi_index_container.html"><img src="../next.gif" alt="multi_index_container reference" border="0"><br>
+<code>multi_index_container</code> reference
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#header_dependencies">Header dependencies</a></li>
+ <li><a href="multi_index_container.html">Class template <code>multi_index_container</code></a></li>
+ <li><a href="indices.html">Index reference</a></li>
+ <li><a href="ord_indices.html">Ordered indices</a></li>
+ <li><a href="rnk_indices.html">Ranked indices</a></li>
+ <li><a href="hash_indices.html">Hashed indices</a></li>
+ <li><a href="seq_indices.html">Sequenced indices</a></li>
+ <li><a href="rnd_indices.html">Random access indices</a></li>
+ <li><a href="key_extraction.html">Key Extraction</a></li>
+</ul>
+
+<h2><a name="header_dependencies">Header dependencies</a></h2>
+
+<p>
+The following dependencies among headers of Boost.MultiIndex hold:
+<ul>
+ <li><a href="multi_index_container.html#synopsis"><code>"boost/multi_index_container.hpp"</code></a>
+ includes
+ <ul>
+ <li><a href="indices.html#indexed_by_synopsis">
+ <code>"boost/multi_index/indexed_by.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="ord_indices.html#synopsis">
+ <code>"boost/multi_index/ordered_index.hpp"</code></a> includes
+ <ul>
+ <li><a href="indices.html#tag_synopsis">
+ <code>"boost/multi_index/tag.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="rnk_indices.html#synopsis">
+ <code>"boost/multi_index/ranked_index.hpp"</code></a> includes
+ <ul>
+ <li><a href="indices.html#tag_synopsis">
+ <code>"boost/multi_index/tag.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="hash_indices.html#synopsis">
+ <code>"boost/multi_index/hashed_index.hpp"</code></a> includes
+ <ul>
+ <li><a href="indices.html#tag_synopsis">
+ <code>"boost/multi_index/tag.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="seq_indices.html#synopsis">
+ <code>"boost/multi_index/sequenced_index.hpp"</code></a> includes
+ <ul>
+ <li><a href="indices.html#tag_synopsis">
+ <code>"boost/multi_index/tag.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="rnd_indices.html#synopsis">
+ <code>"boost/multi_index/random_access_index.hpp"</code></a> includes
+ <ul>
+ <li><a href="indices.html#tag_synopsis">
+ <code>"boost/multi_index/tag.hpp"</code></a>.</li>
+ </ul>
+ </li>
+ <li><a href="key_extraction.html#synopsis"><code>"boost/multi_index/key_extractors.hpp"</code></a>
+ includes
+ <ul>
+ <li><a href="key_extraction.html#identity_synopsis">
+ <code>"boost/multi_index/identity.hpp"</code></a>,</li>
+ <li><a href="key_extraction.html#member_synopsis">
+ <code>"boost/multi_index/member.hpp"</code></a>,</li>
+ <li><a href="key_extraction.html#mem_fun_synopsis">
+ <code>"boost/multi_index/mem_fun.hpp"</code></a>,</li>
+ <li><a href="key_extraction.html#global_fun_synopsis">
+ <code>"boost/multi_index/global_fun.hpp"</code></a> and</li>
+ <li><a href="key_extraction.html#composite_key_synopsis">
+ <code>"boost/multi_index/composite_key.hpp"</code></a>.</li>
+ </ul>
+ </li>
+</ul>
+So, a program using Boost.MultiIndex must include
+<a href="multi_index_container.html#synopsis">
+<code>"boost/multi_index_container.hpp"</code></a>,
+the headers defining the index types to be used and possibly one or more key
+extraction headers for key-based indices. Note that all the key extractors
+provided by Boost.MultiIndex are automatically included with
+<a href="key_extraction.html#synopsis">
+<code>"boost/multi_index/key_extractors.hpp"</code></a>.
+</p>
+
+<p>
+In order to use the serialization capabilities of Boost.MultiIndex,
+the appropriate Boost.Serialization library module must be linked. Other
+than that, Boost.MultiIndex is a header-only library, requiring no additional
+object modules.
+</p>
+
+<hr>
+
+<div class="prev_link"><a href="../tutorial/techniques.html"><img src="../prev.gif" alt="techniques" border="0"><br>
+Techniques
+</a></div>
+<div class="up_link"><a href="../index.html"><img src="../up.gif" alt="index" border="0"><br>
+Index
+</a></div>
+<div class="next_link"><a href="multi_index_container.html"><img src="../next.gif" alt="multi_index_container reference" border="0"><br>
+<code>multi_index_container</code> reference
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised November 24th 2015</p>
+
+<p>© Copyright 2003-2015 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/indices.html b/doc/reference/indices.html
new file mode 100644
index 0000000..a561199
--- /dev/null
+++ b/doc/reference/indices.html
@@ -0,0 +1,399 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Index reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="multi_index_container.html">
+<link rel="up" href="index.html">
+<link rel="next" href="ord_indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Index reference</h1>
+
+<div class="prev_link"><a href="multi_index_container.html"><img src="../prev.gif" alt="multi_index_container reference" border="0"><br>
+<code>multi_index_container</code> reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="ord_indices.html"><img src="../next.gif" alt="ordered indices" border="0"><br>
+Ordered indices
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#index_concepts">Index concepts</a></li>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#index_specification">Index specification</a></li>
+ <li><a href="#indexed_by_synopsis">Header
+ <code>"boost/multi_index/indexed_by.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#indexed_by">Class template <code>indexed_by</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#tags">Tags</a></li>
+ <li><a href="#tag_synopsis">Header
+ <code>"boost/multi_index/tag.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#tag">Class template <code>tag</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#index_catalog">Indices provided by Boost.MultiIndex</a>
+ <ul>
+ <li><a href="#key_based_indices">Key-based indices</a></li>
+ <li><a href="#other_indices">Other types</a></li>
+ </ul>
+ </li>
+ <li><a href="#views">Index views</a></li>
+</ul>
+
+<h2><a name="index_concepts">Index concepts</a></h2>
+
+<p>
+<code>multi_index_container</code> instantiations comprise one or more indices
+specified at compile time. Each index allows read/write access to the elements
+contained in a definite manner. For instance,
+<a href="ord_indices.html">ordered indices</a>
+provide a set-like interface to the elements, whereas
+<a href="seq_indices.html">sequenced indices</a> mimic the functionality
+of <code>std::list</code>.
+</p>
+
+<p>
+Indices are not isolated objects, and so cannot be constructed on their
+own. Rather they are embedded into a <code>multi_index_container</code> as specified by
+means of an <a href="#index_specification">index specifier</a>. The name of
+the index class implementation proper is never directly exposed to the user, who
+has only access to the associated index specifier.
+</p>
+
+<p>
+Insertion and erasing of elements are always performed through the
+appropriate interface of some index of the <code>multi_index_container</code>;
+these operations, however, do have an impact on all other indices as
+well: for instance, insertion through a given index may fail because
+there exists another index which bans the operation in order to preserve
+its invariant (like uniqueness of elements.) This circumstance, rather
+than being an obstacle, yields much of the power of Boost.MultiIndex:
+equivalent constructions based on manual composition of standard
+containers would have to add a fair amount of code in order to
+globally preserve the invariants of each container while guaranteeing
+that all of them are synchronized. The global operations performed
+in a joint manner among the various indices can be reduced to
+six primitives:
+<ul>
+ <li>Copying,</li>
+ <li>insertion of an element,</li>
+ <li>hinted insertion, where a preexisting element is suggested in
+ order to improve the efficiency of the operation,</li>
+ <li>deletion of an element,</li>
+ <li>replacement of the value of an element,
+ which may trigger the rearrangement of this element in one or
+ more indices, or the banning of the replacement,</li>
+ <li>modification of an element, and its subsequent
+ rearrangement/banning by the various indices.
+</ul>
+The last two primitives deserve some further explanation: in order to
+guarantee the invariants associated to each index (e.g. some definite
+ordering,) elements of a <code>multi_index_container</code> are not mutable.
+To overcome this restriction, indices expose member functions
+for replacement and modification which allow for the mutation of elements
+in a controlled fashion. Immutability of elements does not significantly
+impact the interfaces of ordered and hashed indices, as they are based upon
+those of associative and unordered associative containers, respectively,
+and these containers
+also have non-mutable elements; but it may come as a surprise when dealing
+with sequenced and random access indices, which are designed upon the functionality provided
+by <code>std::list</code>.
+</p>
+
+<p>
+These global operations are not directly exposed to the user, but rather
+they are wrapped as appropriate by each index (for instance, ordered indices
+provide a set-like suite of insertion member functions, whereas sequenced
+and random access indices have <code>push_back</code> and <code>push_front</code>
+operations.) Boost.MultiIndex poses no particular conditions on
+the interface of indices, although each index provided satisfy the C++ requirements for
+standard containers to the maximum extent possible within the conceptual framework
+of the library.
+</p>
+
+<h2><a name="complexity_signature">Complexity signature</a></h2>
+
+<p>
+Some member functions of an index interface are implemented by
+global primitives from the list above. Complexity of these operations
+thus depends on all indices of a given <code>multi_index_container</code>, not just
+the currently used index.
+</p>
+
+<p>
+In order to establish complexity estimates, an index is characterized
+by its <i>complexity signature</i>, consisting of the following
+associated functions on the number of elements:
+<ul>
+ <li><code>c(n)</code>: copying,
+ <li><code>i(n)</code>: insertion,
+ <li><code>h(n)</code>: hinted insertion,
+ <li><code>d(n)</code>: deletion,
+ <li><code>r(n)</code>: replacement,
+ <li><code>m(n)</code>: modifying.
+</ul>
+
+</p>
+Each function yields the complexity estimate of the contribution of the index
+to the corresponding global primitive. Let us consider
+an instantiation of <code>multi_index_container</code>
+with <code>N</code> indices labelled <code>0</code>,...,<code>N-1</code>
+whose complexity signatures are
+(<code>c<sub>i</sub></code>,<code>i<sub>i</sub></code>,<code>h<sub>i</sub></code>,<code>d<sub>i</sub></code>,<code>r<sub>i</sub></code>,<code>m<sub>i</sub></code>);
+the insertion of an element in such a container is then of complexity
+<code>O(i<sub>0</sub>(n)+···+i<sub>N-1</sub>(n))</code> where <code>n</code>
+is the number of elements. To abbreviate notation, we adopt the
+following definitions:
+<ul>
+ <li><code>C(n)=c<sub>0</sub>(n)+···+c<sub>N-1</sub>(n)</code>,</li>
+ <li><code>I(n)=i<sub>0</sub>(n)+···+i<sub>N-1</sub>(n)</code>,</li>
+ <li><code>H(n)=h<sub>0</sub>(n)+···+h<sub>N-1</sub>(n)</code>,</li>
+ <li><code>D(n)=d<sub>0</sub>(n)+···+d<sub>N-1</sub>(n)</code>,</li>
+ <li><code>R(n)=r<sub>0</sub>(n)+···+r<sub>N-1</sub>(n)</code>,</li>
+ <li><code>M(n)=m<sub>0</sub>(n)+···+m<sub>N-1</sub>(n)</code>.</li>
+</ul>
+For instance, consider a <code>multi_index_container</code> with two ordered indices,
+for which <code>i(n)=log(n)</code>, and a sequenced index with <code>i(n)=1</code>
+(constant time insertion). Insertion of an element into this <code>multi_index_container</code>
+is then of complexity
+<blockquote>
+<code>O(I(n))=O(2*log(n)+1)=O(log(n))</code>.
+</blockquote>
+</p>
+
+<h2><a name="index_specification">Index specification</a></h2>
+
+<p>
+Index specifiers are passed as instantiation arguments to
+<code>multi_index_container</code> and provide the information needed to incorporate
+the corresponding indices. Future releases of Boost.MultiIndex may allow for
+specification of user-defined indices. Meanwhile, the requirements for an index
+specifier remain implementation defined. Currently, Boost.MultiIndex provides the
+index specifiers
+<ul>
+ <li><a href="ord_indices.html#unique_non_unique"><code>ordered_unique</code> and
+ <code>ordered_non_unique</code></a> for
+ <a href="ord_indices.html">ordered indices</a>,</li>
+ <li><a href="rnk_indices.html#unique_non_unique"><code>ranked_unique</code> and
+ <code>ranked_non_unique</code></a> for
+ <a href="rnk_indices.html">ranked indices</a>,</li>
+ <li><a href="hash_indices.html#unique_non_unique"><code>hashed_unique</code> and
+ <code>hashed_non_unique</code></a> for
+ <a href="hash_indices.html">hashed indices</a>,</li>
+ <li><a href="seq_indices.html#sequenced"><code>sequenced</code></a> for
+ <a href="seq_indices.html">sequenced indices</a>,</li>
+ <li>and <a href="rnd_indices.html#random_access"><code>random_access</code></a> for
+ <a href="rnd_indices.html">random access indices</a>.</li>
+</ul>
+</p>
+
+<h2>
+<a name="indexed_by_synopsis">Header
+<a href="../../../../boost/multi_index/indexed_by.hpp">
+<code>"boost/multi_index/indexed_by.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>T0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Tn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>indexed_by</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="indexed_by">Class template <code>indexed_by</code></a></h3>
+
+<p>
+<code>indexed_by</code> is a model of
+<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+<code>MPL Random Access Sequence</code></a> and
+<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
+<code>MPL Extensible Sequence</code></a> meant to be used to specify a
+compile-time list of indices as the <code>IndexSpecifierList</code> of
+<code>multi_index_container</code>.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>T0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Tn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>indexed_by</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>
+Each user-provided element of <code>indexed_list</code> must be an index
+specifier. At least an element must be provided. The maximum number of elements
+of an <code>indexed_by</code> sequence is implementation defined.
+</p>
+
+<h2><a name="tags">Tags</a></h2>
+
+<p>
+Tags are just conventional types used as mnemonics for indices of an
+<code>multi_index_container</code>, as for instance in member function <code>get</code>.
+Each index can have none, one or more tags associated. The way tags are assigned
+to a given index is dependent on the particular index specifier. However,
+for convenience all indices of Boost.MultiIndex support tagging through the
+class template <a href="#tag"><code>tag</code></a>.
+</p>
+
+<h2>
+<a name="tag_synopsis">Header
+<a href="../../../../boost/multi_index/tag.hpp">
+<code>"boost/multi_index/tag.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>T0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Tn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>tag</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="tag">Class template <code>tag</code></a></h3>
+
+<p>
+<code>tag</code> is a typelist construct used to specify a compile-time
+sequence of tags to be assigned to an index in instantiation time.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>T0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Tn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>tag</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+Elements of <code>tag</code> can be any type, though the user is expected
+to provide classes with mnemonic names. Duplicate elements are not allowed.
+The maximum number of elements of a <code>tag</code> instantiation is
+implementation defined.
+The nested
+<code>type</code> is a model of
+<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+<code>MPL Random Access Sequence</code></a> and
+<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
+<code>MPL Extensible Sequence</code></a> containing the types <code>T0</code>, ... ,
+<code>Tn</code> in the same order as specified.
+</p>
+
+<h2><a name="index_catalog">Indices provided by Boost.MultiIndex</a></h2>
+
+
+<h3><a name="key_based_indices">Key-based indices</a></h3>
+
+<p>
+Indices of this type are organized around <i>keys</i> obtained from the
+elements, as described in the <a href="key_extraction.html">key extraction
+reference</a>.
+<ul>
+ <li><a href="ord_indices.html">Ordered indices</a> sort the elements
+ on the key and provide fast lookup capabilites.</li>
+ <li><a href="rnk_indices.html">Ranked indices</a> are a variation of
+ ordered indices providing extra operations based on
+ <i>rank</i>, the numerical position of an element
+ in the sequence.</li>
+ <li><a href="hash_indices.html">Hashed indices</a> offer high
+ efficiency access through hashing techniques.</li>
+</ul>
+</p>
+
+<h3><a name="other_indices">Other types</a></h3>
+
+<p>
+<ul>
+ <li><a href="seq_indices.html">Sequenced indices</a> allow to arrange
+ elements as in a bidirectional list.</li>
+ <li><a href="rnd_indices.html">Random access indices</a> provide
+ constant time positional access and free ordering of elements.</li>
+</ul>
+</p>
+
+<h2><a name="views">Index views</a></h2>
+
+<p>
+The following concept is used by the rearrange facilities of non key-based
+indices. Given an index <code>i</code> of type <code>Index</code>, a <i>view
+of <code>i</code></i> is any range [<code>first</code>,<code>last</code>)
+where <code>first</code> and <code>last</code> are input iterators such that
+<ol>
+ <li>the associated value type of <code>Iterator</code> is convertible
+ to <code>const Index::value_type&</code>
+ </li>
+ <li>and each of the elements of <code>i</code> appears exactly once in
+ [<code>first</code>,<code>last</code>).
+ </li>
+</ol>
+Note that the view refers to the actual elements of <code>i</code>, not to
+copies of them. Additionally, a view is said to be <i>free</i> if its traversal
+order is not affected by changes in the traversal order of <code>i</code>.
+Examples of free views are:
+<ul>
+ <li>[<code>c.begin()</code>,<code>c.end()</code>), where <code>c</code> is
+ any container of reference wrappers (from
+ <a href="../../../../doc/html/ref.html">Boost.Ref</a>) to the elements
+ of <code>i</code> containing exactly one reference to every element.
+ </li>
+ <li>[<code>i'.begin()</code>,<code>i'.end()</code>), where <code>i'</code> is
+ any index belonging to the same <code>multi_index_container</code>
+ as <code>i</code>, except <code>i</code> itself.
+ </li>
+ <li>
+ Any range which is a permutation of the ones described above, as for
+ instance [<code>c.rbegin()</code>,<code>c.rend()</code>), or
+ ranges obtained from the former with the aid of
+ <a href="../../../../libs/iterator/doc/permutation_iterator.html">
+ <code>permutation_iterator</code></a> from Boost.Iterator.
+ </li>
+</ul>
+</p>
+
+<hr>
+
+<div class="prev_link"><a href="multi_index_container.html"><img src="../prev.gif" alt="multi_index_container reference" border="0"><br>
+<code>multi_index_container</code> reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="ord_indices.html"><img src="../next.gif" alt="ordered indices" border="0"><br>
+Ordered indices
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised April 19th 2015</p>
+
+<p>© Copyright 2003-2015 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/key_extraction.html b/doc/reference/key_extraction.html
new file mode 100644
index 0000000..f618c39
--- /dev/null
+++ b/doc/reference/key_extraction.html
@@ -0,0 +1,2082 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Key extraction reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="rnd_indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="../compiler_specifics.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Key extraction reference</h1>
+
+<div class="prev_link"><a href="rnd_indices.html"><img src="../prev.gif" alt="random access indices" border="0"><br>
+Random access indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
+Compiler specifics
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#key_extractors">Key Extractors</a>
+ <ul>
+ <li><a href="#chained_pointers">Chained pointers</a></li>
+ </ul>
+ </li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/key_extractors.hpp"</code> synopsis</a>
+ </li>
+ <li><a href="#identity_synopsis">Header
+ <code>"boost/multi_index/identity.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#identity">Class template <code>identity</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#member_synopsis">Header
+ <code>"boost/multi_index/member.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#member">Class template <code>member</code></a></li>
+ <li><a href="#member_offset">Class template <code>member_offset</code></a></li>
+ <li><a href="#boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#mem_fun_synopsis">Header
+ <code>"boost/multi_index/mem_fun.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#const_mem_fun">Class template <code>const_mem_fun</code></a></li>
+ <li><a href="#mem_fun">Class template <code>mem_fun</code></a></li>
+ <li><a href="#const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></li>
+ <li><a href="#boost_multi_index_const_mem_fun">Macros <code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code> and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#global_fun_synopsis">Header
+ <code>"boost/multi_index/global_fun.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#global_fun">Class template <code>global_fun</code></a></li>
+ </ul>
+ </li>
+ <li><a href="#composite_key_synopsis">Header
+ <code>"boost/multi_index/composite_key.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#composite_key">Class template <code>composite_key</code></a></li>
+ <li><a href="#composite_key_result">Class template <code>composite_key_result</code></a></li>
+ <li><a href="#ckey_result_equality">Equality</a>
+ <ul>
+ <li><a href="#composite_key_equal_to">Class template <code>composite_key_equal_to</code></a></li>
+ <li><a href="#composite_key_result_equal_to">Class template <code>composite_key_result_equal_to</code></a></li>
+ <li><a href="#equal_to_composite_key_result">Specialization of <code>std::equal_to</code> for <code>composite_key</code> results</a></li>
+ </ul>
+ </li>
+ <li><a href="#ckey_result_comparison">Comparison</a>
+ <ul>
+ <li><a href="#composite_key_compare">Class template <code>composite_key_compare</code></a></li>
+ <li><a href="#composite_key_result_less">Class template <code>composite_key_result_less</code></a></li>
+ <li><a href="#composite_key_result_greater">Class template <code>composite_key_result_greater</code></a></li>
+ <li><a href="#less_composite_key_result">Specialization of <code>std::less</code> for <code>composite_key</code> results</a></li>
+ <li><a href="#greater_composite_key_result">Specialization of <code>std::greater</code> for <code>composite_key</code> results</a></li>
+ </ul>
+ </li>
+ <li><a href="#ckey_result_hashing">Hashing</a>
+ <ul>
+ <li><a href="#composite_key_hash">Class template <code>composite_key_hash</code></a></li>
+ <li><a href="#composite_key_result_hash">Class template <code>composite_key_result_hash</code></a></li>
+ <li><a href="#hash_composite_key_result">Specialization of <code>boost::hash</code> for <code>composite_key</code> results</a></li>
+ </ul>
+ </li>
+ <li><a href="#ckey_result_semantics">Semantics of <code>composite_key_result</code></a></li>
+ </ul>
+ </li>
+</ul>
+
+<h2><a name="key_extractors">Key Extractors</a></h2>
+
+<p>
+Key extraction classes are used by
+<a href="indices.html#key_based_indices">key-based indices</a> to
+obtain the indexing keys from the elements of a <code>multi_index_container</code>.
+A <code>CopyConstructible</code> and <code>CopyAssignable</code>
+class <code>KeyFromValue</code> is said to be a key extractor from a
+type <code>Type</code> if
+<ol>
+ <li>the type <code>KeyFromValue::result_type</code> is defined,</li>
+ <li><code>k1(ca)</code> is defined and returns a value convertible
+ to <code>const KeyFromValue::result_type&</code>,</li>
+ <li>if <code>k2</code> is a copy of <code>k1</code>, <code>k1(ca)</code> is the
+ same value as <code>k2(ca)</code>,</li>
+</ol>
+for every <code>k1</code>, <code>k2</code> of type <code>const KeyFromValue</code>,
+and <code>ca</code> of type <code>const Type&</code>.
+</p>
+
+<p>
+Additionally, <code>KeyFromValue</code> is a <i>read/write</i> key extractor
+if the following extra conditions are met:
+<ol>
+ <li><code>k1(a)</code> is defined and returns a value convertible
+ to <code>KeyFromValue::result_type&</code>,</li>
+ <li><code>const_cast<const KeyFromValue::result_type&>(k1(a))</code>
+ is the same value as
+ <code>k1(const_cast<const Type&>(a))</code>,</li>
+</ol>
+for every <code>k1</code> of type <code>const KeyFromValue</code> and
+<code>a</code> of type <code>Type&</code>.
+</p>
+
+<p>
+Boost.MultiIndex provides six general-purpose key extractors:
+<ul>
+ <li><a href="#identity"><code>identity</code></a>,</li>
+ <li><a href="#member"><code>member</code></a>,</li>
+ <li><a href="#const_mem_fun"><code>const_mem_fun</code></a>,</li>
+ <li><a href="#mem_fun"><code>mem_fun</code></a>,</li>
+ <li><a href="#global_fun"><code>global_fun</code></a> and</li>
+ <li><a href="#composite_key"><code>composite_key</code></a>.</li>
+</ul>
+</p>
+
+<h3><a name="chained_pointers">Chained pointers</a></h3>
+
+<p>
+The key extractors provided by Boost.MultiIndex are templatized according
+to the type <code>Type</code> and serve to extract keys not only from objects
+of type <code>Type</code>, but also from reference wrappers provided by
+<a href="../../../../doc/html/ref.html">Boost.Ref</a> and from <i>chained pointers</i>
+to <code>Type</code> (or to reference wrappers of <code>Type</code>): a chained pointer
+is any type <code>P</code> such that, for an object <code>p</code> of type
+<code>const P</code>
+<ul>
+ <li><code>*p</code> yields an object of type <code>Type&</code> or
+ <code>boost::reference_wrapper<Type></code>, OR</li>
+ <li><code>*p</code> yields a chained pointer to <code>Type</code>,</li>
+</ul>
+that is, chained pointers are arbitrary compositions of pointer-like objects
+ultimately dereferencing to values of <code>Type&</code> or
+<code>boost::reference_wrapper<Type></code>.
+<p>
+
+<h2><a name="synopsis">Header
+<a href="../../../../boost/multi_index/key_extractors.hpp">
+<code>"boost/multi_index/key_extractors.hpp"</code></a> synopsis</a>
+</h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>identity</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>></span>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>member</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>></span>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>mem_fun</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>></span>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>global_fun</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>></span>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>composite_key</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>></span>
+</pre></blockquote>
+
+<p>
+This header includes all the key extractors provided by Boost.MultiIndex.
+</p>
+
+<h2>
+<a name="identity_synopsis">Header
+<a href="../../../../boost/multi_index/identity.hpp">
+<code>"boost/multi_index/identity.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>></span> <span class=keyword>struct</span> <span class=identifier>identity</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="identity">Class template <code>identity</code></a></h3>
+
+<p>
+<code>identity</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+that acts as a do-nothing identity functor.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>identity</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=comment>// only provided if const ChainedPtr& is not convertible to const Type&</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>></span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> <span class=comment>// only provided if Type is non-const
+
+ // only provided if Type is non-const</span>
+ <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>const</span> <span class=identifier>Type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Type is const</span>
+ <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>remove_const</span><span class=special><</span><span class=identifier>Type</span><span class=special>>::</span><span class=identifier>type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=identifier>Type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>identity<Type></code> is a model of:
+<ul>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>Type</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<const Type></code>,</li>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<Type></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a> to
+ <code>const Type</code>,</li>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>Type</code>.</li>
+</ul>
+</p>
+
+<h4><code>identity</code> members</h4>
+
+<code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>Type</code>.<br>
+<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>const Type& operator()(const Type& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x</code>.
+</blockquote>
+
+<code>Type& operator()(Type& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x</code>.
+</blockquote>
+
+<code>const Type& operator()(const reference_wrapper<const Type>& x)const;</code>
+<blockquote>
+<b>Returns:</b> <code>x.get()</code>.
+</blockquote>
+
+<code>Type& operator()(const reference_wrapper<typename remove_const<Type>::type>& x)const;</code>
+<blockquote>
+<b>Returns:</b> <code>x.get()</code>.
+</blockquote>
+
+<code>Type& operator()(const reference_wrapper<Type>& x)const;</code>
+<blockquote>
+<b>Returns:</b> <code>x.get()</code>.
+</blockquote>
+
+
+<h2>
+<a name="member_synopsis">Header
+<a href="../../../../boost/multi_index/member.hpp">
+<code>"boost/multi_index/member.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMember</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>member</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>OffsetOfMember</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>member_offset</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberName</span><span class=special>)</span> <b>implementation defined</b>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="member">Class template <code>member</code></a></h3>
+
+<p>
+<code>member</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+aimed at accessing a given member of a class.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMember</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>member</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=comment>// only provided if const ChainedPtr& is not convertible to const Class&</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>></span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Class</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> <span class=comment>// only provided if Type is non-const</span>
+ <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span><span class=special>&</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=identifier>Class</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+The <code>PtrToMember</code> template argument specifies the particular
+<code>Type Class::*</code> pointer to the member to be extracted.
+<code>member<Class,Type,PtrToMember></code> is a model of:
+<ul>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>Class</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<const Class></code>,</li>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<Class></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>const Class</code>,</li>
+ <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>Class</code>.</li>
+</ul>
+</p>
+
+<h4><code>member</code> members</h4>
+
+<code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>Type</code>.<br>
+<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>const Type& operator()(const Class& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x.*PtrToMember</code>.
+</blockquote>
+
+<code>Type& operator()(Class& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x.*PtrToMember</code>.
+</blockquote>
+
+<code>const Type& operator()(const reference_wrapper<const Class>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x.get().*PtrToMember</code>.
+</blockquote>
+
+<code>Type& operator()(const reference_wrapper<Class>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>x.get().*PtrToMember</code>.
+</blockquote>
+
+<h3><a name="member_offset">Class template <code>member_offset</code></a></h3>
+
+<p>
+<code>member_offset</code> was designed to overcome limitations of some legacy
+compilers and its use is currently deprecated. Refer to a
+<a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#member_offset">former version</a>
+of Boost.MultiIndex for further information.
+</p>
+
+<h3><a name="boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></h3>
+
+<blockquote><pre>
+<span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberName</span><span class=special>)</span>
+</pre></blockquote>
+
+<p>
+This macro was designed as a portability mechanism for legacy compilers where <code>member</code>
+could not be supported.
+As such it is no longer needed in modern environments, though some users might still prefer it
+to plain <code>member</code> because it provides a slightly more concise syntax.
+</p>
+
+<h2>
+<a name="mem_fun_synopsis">Header
+<a href="../../../../boost/multi_index/mem_fun.hpp">
+<code>"boost/multi_index/mem_fun.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()</span><span class=keyword>const</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>const_mem_fun</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()></span>
+<span class=keyword>struct</span> <span class=identifier>mem_fun</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>const_mem_fun_explicit</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>mem_fun_explicit</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_CONST_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span> <span class=special>\</span>
+<b>implementation defined</b>
+<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span> <span class=special>\</span>
+<b>implementation defined</b>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="const_mem_fun">Class template <code>const_mem_fun</code></a></h3>
+
+<p>
+<code>const_mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+returning as key the result of invoking a given constant member function of a class.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()</span><span class=keyword>const</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>const_mem_fun</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special><</span><span class=identifier>Type</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=comment>// only provided if const ChainedPtr& is not convertible to const Class&</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>></span> <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=identifier>Class</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+The <code>PtrToMemberFunction</code> template argument specifies the particular
+<code>Type (Class::*PtrToMemberFunction)()const</code> pointer to the constant
+member function used in the extraction.
+<code>const_mem_fun<Class,Type,PtrToMemberFunction></code> is a model of:
+<ul>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>Class</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<const Class></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<Class></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>const Class</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>Class</code>.</li>
+</ul>
+</p>
+
+<h4><code>const_mem_fun</code> members</h4>
+
+<code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>Type</code>.<br>
+<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
+object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>Type operator()(const Class& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
+</blockquote>
+
+<code>Type operator()(const reference_wrapper<const Class>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
+</blockquote>
+
+<code>Type operator()(const reference_wrapper<Class>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
+</blockquote>
+
+<h3><a name="mem_fun">Class template <code>mem_fun</code></a></h3>
+
+<p>
+<code>mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+returning as key the result of invoking a given member function of a class.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()></span>
+<span class=keyword>struct</span> <span class=identifier>mem_fun</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special><</span><span class=identifier>Type</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=comment>// only provided if ChainedPtr& is not convertible to Class&</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>></span> <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Class</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=identifier>Class</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+The <code>PtrToMemberFunction</code> template argument specifies the particular
+<code>Type (Class::*PtrToMemberFunction)()</code> pointer to the member
+function used in the extraction.
+<code>mem_fun<Class,Type,PtrToMemberFunction></code> is a model of:
+<ul>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<Class></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>Class</code>.</li>
+</ul>
+</p>
+
+<h4><code>mem_fun</code> members</h4>
+
+<code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>Type</code>.<br>
+<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
+object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>Type operator()(Class& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
+</blockquote>
+
+<code>Type operator()(const reference_wrapper<Class>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
+</blockquote>
+
+<h3><a name="const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></h3>
+
+<p>
+These extractors were provided as a workaround for MSVC++ 6.0 and are now deprecated.
+Refer to a
+<a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#const_mem_fun_explicit">former version</a>
+of Boost.MultiIndex for further information.
+</p>
+
+<h3><a name="boost_multi_index_const_mem_fun">Macros
+<code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code>
+and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></h3>
+
+<blockquote><pre>
+<span class=identifier>BOOST_MULTI_INDEX_CONST_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span>
+<span class=identifier>BOOST_MULTI_INDEX_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span>
+</pre></blockquote>
+
+<p>
+Portability macros for usage of <code>const_mem_fun</code> and <code>mem_fun</code>.
+Although no longer needed in modern compilers, some users might still decide to
+resort to them as they provide a slightly more concise syntax.
+</p>
+
+<h2>
+<a name="global_fun_synopsis">Header
+<a href="../../../../boost/multi_index/global_fun.hpp">
+<code>"boost/multi_index/global_fun.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(*</span><span class=identifier>PtrToFunction</span><span class=special>)(</span><span class=identifier>Value</span><span class=special>)></span>
+<span class=keyword>struct</span> <span class=identifier>global_fun</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="global_fun">Class template <code>global_fun</code></a></h3>
+
+<p>
+<code>global_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+based on a given global or static member function accepting the base type as argument
+and returning the associated key.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>class</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(*</span><span class=identifier>PtrToFunction</span><span class=special>)(</span><span class=identifier>Value</span><span class=special>)></span>
+<span class=keyword>struct</span> <span class=identifier>global_fun</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special><</span><span class=identifier>Type</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=comment>// Only provided under the following circumstances:
+ // - If Value is a reference to a constant type, only provided
+ // when const ChainedPtr& is not convertible to Value;
+ // - if Value is a reference to a non-const type, only provided
+ // when ChainedPtr& is not convertible to Value;
+ // - else, only provided when const ChainedPtr& is not
+ // convertible to const Value&.</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Value is a reference type</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Value</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Value is not a reference type</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Value is not a reference type</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Value is a reference type</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span>
+ <span class=identifier>remove_reference</span><span class=special><</span><span class=identifier>Value</span><span class=special>>::</span><span class=identifier>type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// only provided if Value is not a reference type or is
+ // a reference to a constant type</span>
+ <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>remove_const</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special><</span><span class=identifier>Value</span><span class=special>>::</span><span class=identifier>type</span><span class=special>>::</span><span class=identifier>type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>PtrToFunction</code> specifies the particular function used to extract
+the key of type <code>Type</code> from some <code>BaseType</code>.
+<code>global_fun</code> supports the following function signatures:
+<ul>
+ <li><code>Type f(BaseType)</code> (<code>Value</code> is <code>BaseType</code>),</li>
+ <li><code>Type f(const BaseType&)</code> (<code>Value</code> is <code>const BaseType&</code>),</li>
+ <li><code>Type f(BaseType&)</code> (<code>Value</code> is <code>BaseType&</code>).</li>
+</ul>
+<code>global_fun<Type,Value,PtrToFunction></code> is a model of:
+<ul>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<BaseType></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>BaseType</code>.</li>
+</ul>
+When <code>Value</code> is <code>BaseType</code> or
+<code>const BaseType&</code>,
+<code>global_fun<Type,Value,PtrToFunction></code> is also a model of:
+<ul>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>BaseType</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<const BaseType></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>const BaseType</code>.</li>
+</ul>
+</p>
+
+<h4><code>global_fun</code> members</h4>
+
+<code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>Value</code>.<br>
+<b>Returns:</b> <code>PtrToFunction)(y)</code>, where <code>y</code> is the
+object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>Type operator()(Value x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>PtrToFunction(x)</code>.
+</blockquote>
+
+<code>Type operator()(const Value& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>PtrToFunction(x)</code>.
+</blockquote>
+
+<code>Type operator()(const reference_wrapper<const Value>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
+</blockquote>
+
+<code>
+Type operator()(<br>
+ const reference_wrapper<remove_reference<Value>::type>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
+</blockquote>
+
+<code>Type operator()(<br>
+ const reference_wrapper<<br>
+ typename remove_const<<br>
+ typename remove_reference<Value>::type>::type>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
+</blockquote>
+
+<h2>
+<a name="composite_key_synopsis">Header
+<a href="../../../../boost/multi_index/composite_key.hpp">
+<code>"boost/multi_index/composite_key.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValue0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValuen</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result</span><span class=special>;</span>
+
+<span class=comment>// comparison operators for composite_key_result:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// equality functors:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Pred0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Predn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_equal_to</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result_equal_to</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=comment>// comparison functors:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Comparen</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result_less</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result_greater</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=comment>// hash functors:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Hash0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Hashn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_hash</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result_hash</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+
+<span class=comment>// specializations of external functors for composite_key_result:</span>
+
+<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>equal_to</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>less</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>greater</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace std</span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hash</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="composite_key">Class template <code>composite_key</code></a></h3>
+
+<p>
+<code>composite_key</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
+returning the combined value of several key extractors whose type is specified
+at compile time. The returned object is of type
+<a href="#composite_key_result">
+<code>composite_key_result</code></a><code><composite_key></code>.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValue0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValuen</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>KeyFromValue0</span><span class=special>,...,</span><span class=identifier>KeyFromValuen</span><span class=special>></span> <span class=identifier>key_extractor_tuple</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>composite_key</span><span class=special>></span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=identifier>composite_key</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>KeyFromValue0</span><span class=special>&</span> <span class=identifier>k0</span><span class=special>=</span><span class=identifier>KeyFromValue0</span><span class=special>(),</span>
+ <span class=special>...</span>
+ <span class=keyword>const</span> <span class=identifier>KeyFromValuen</span><span class=special>&</span> <span class=identifier>kn</span><span class=special>=</span><span class=identifier>KeyFromValuen</span><span class=special>());</span>
+
+ <span class=identifier>composite_key</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_extractor_tuple</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>const</span> <span class=identifier>key_extractor_tuple</span><span class=special>&</span> <span class=identifier>key_extractors</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_extractor_tuple</span><span class=special>&</span> <span class=identifier>key_extractors</span><span class=special>()</span>
+
+ <span class=comment>// only provided if const ChainedPtr& is not convertible to const value_type&</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>></span>
+ <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special><</span><span class=identifier>value_type</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>KeyFromValue0</code>, ... , <code>KeyFromValuen</code> are the types of
+the key extractors combined into the composite key. Each of these types
+must be a <a href="#key_extractors"><code>Key Extractor</code></a> from
+<code>Value</code>. At least a key extractor must be provided. The maximum
+number of key extractors of a <code>composite_key</code> instantiation is
+implementation defined. <code>composite_key</code> internally stores an
+object of every constituent key extractor type.
+<code>composite_key<Value,KeyFromValue0,...,KeyFromValuen></code> is a model
+of:
+<ul>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>Value</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<const Value></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from <code>reference_wrapper<Value></code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>const Value</code>,</li>
+ <li><a href="#key_extractors"><code>Key Extractor</code></a>
+ from any <a href="#chained_pointers">chained pointer</a>
+ to <code>Value</code>.</li>
+</ul>
+</p>
+
+<h4><code>composite_key</code> members</h4>
+
+<code>composite_key(<br>
+ const KeyFromValue0& k0=KeyFromValue0(),<br>
+ ...<br>
+ const KeyFromValuen& kn=KeyFromValuen());
+</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key</code> that stores
+copies of the key extractor objects supplied.
+</blockquote>
+
+<code>composite_key(const key_extractor_tuple& x);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key</code> that stores
+copies of the key extractor objects supplied in <code>x</code>.
+</blockquote>
+
+<code>const key_extractor_tuple& key_extractors()const;</code>
+
+<blockquote>
+<b>Returns:</b> a constant reference to a tuple holding the
+key extractors internally stored by the <code>composite_key</code>.
+</blockquote>
+
+<code>key_extractor_tuple& key_extractors();</code>
+
+<blockquote>
+<b>Returns:</b> a reference to a tuple holding the
+key extractors internally stored by the <code>composite_key</code>.
+</blockquote>
+
+<code>template<typename ChainedPtr><br>
+result_type operator()(const ChainedPtr& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
+type to <code>result_type</code>.<br>
+<b>Returns:</b> a <code>result_type</code> object dependent on
+<code>*this</code> and <code>y</code>, where <code>y</code> is the
+object chained-pointed to by <code>x</code>.
+</blockquote>
+
+<code>result_type operator()(const value_type& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> a <code>result_type</code> object dependent on
+<code>*this</code> and <code>x</code>.
+</blockquote>
+
+<code>result_type operator()(const reference_wrapper<const value_type>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> a <code>result_type</code> object dependent on
+<code>*this</code> and <code>x.get()</code>.
+</blockquote>
+
+<code>result_type operator()(const reference_wrapper<value_type>& x)const;</code>
+
+<blockquote>
+<b>Returns:</b> a <code>result_type</code> object dependent on
+<code>*this</code> and <code>x.get()</code>.
+</blockquote>
+
+<h3><a name="composite_key_result">Class template
+<code>composite_key_result</code></a></h3>
+
+<p>
+This is an opaque type returned by <code>composite_key</code>
+instantiations as their extracted key.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_result</span>
+<span class=special>{</span>
+ <b>no public interface available</b>
+<span class=special>};</span>
+
+<span class=comment>// comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+</pre></blockquote>
+
+<code>CompositeKey</code> is the <code>composite_key</code> instantiation to
+which the <code>composite_key_result</code> type is associated. Objects of type
+<code>composite_key_result</code> returned by a composite key must be always treated
+as <i>temporary</i>, i.e. they should not be stored or copied.
+<code>composite_key_result</code> is <i>not</i> guaranteed to be
+<code>DefaultConstructible</code> or <code>CopyAssignable</code>.
+Every object of type <code>composite_key_result<CompositeKey></code> is
+internally associated to the <code>CompositeKey</code> from which it is returned
+and the object of type <code>CompositeKey::value_type</code> to which the
+composite key was applied.
+</p>
+
+<h4><a name="ckey_result_notation">Notation</a></h4>
+
+<p>
+Given an <code>x</code> of type <code>composite_key_result<CompositeKey></code>,
+we use the following notation:
+<ul>
+ <li><code>ck(x)</code> is the <code>CompositeKey</code> object associated to
+ <code>x</code>,</li>
+ <li><code>v(x)</code> is the object of type <code>CompositeKey::value_type</code>
+ associated to <code>x</code>,</li>
+ <li><code>k<sub>i</sub>(x) = ck(x).key_extractors().get<i>()</code>,
+ that is, is the <code>i</code>-th key extractor of <code>ck(x)</code>,</li>
+ <li><code>x<sub>i</sub> = k<sub>i</sub>(x)(v(x))</code>, that is, the
+ key extracted from <code>v(x)</code> by the <code>i</code>-th key extractor,</li>
+ <li><code>length(x)</code> is the number of key extractors of <code>ck(x)</code>.</li>
+</ul>
+Also, if <code>y</code> is an <code>std::tuple</code> or <code>boost::tuple</code> of values, we define:
+<ul>
+ <li><code>y<sub>i</sub>=get<i>(y)</code>,</li>
+ <li><code>length(y)</code> is the number of elements of <code>y</code>.</li>
+</ul>
+</p>
+
+<h4>Comparison operators</h4>
+
+<code>template<typename CompositeKey1,typename CompositeKey2><br>
+bool operator==(<br>
+ const composite_key_result<CompositeKey1>& x,<br>
+ const composite_key_result<CompositeKey2>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator==(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const std::tuple<Values...>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator==(<br>
+ const std::tuple<Values...>& x,<br>
+ const composite_key_result<CompositeKey>& y);<br>
+template<typename CompositeKey,typename Value0,...,typename Valuen><br>
+bool operator==(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const boost::tuple<Value0,...,Valuen>& y);<br>
+template<typename Value0,...,typename Valuen,typename CompositeKey><br>
+bool operator==(<br>
+ const boost::tuple<Value0,...,Valuen>& x,<br>
+ const composite_key_result<CompositeKey>& y);
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>length(x)==length(y)</code>. The expression
+<code>x<sub>i</sub>==y<sub>i</sub></code> is valid for all <code>i</code>
+in <code>[0,length(x))</code>.<br>
+<b>Returns:</b> <code>true</code> if and only if
+<blockquote>
+<code>x<sub>i</sub>==y<sub>i</sub></code> for all <code>i</code>
+in <code>[0,length(x))</code>.
+</blockquote>
+<b>Complexity:</b> No more key extraction operations and comparisons
+are performed than those necessary for the evaluation of the expression above,
+starting at <code>i==0</code>. The evaluation is short-circuited as soon as
+the result is determined to be <code>false</code>.
+</blockquote>
+
+<code>template<typename CompositeKey1,typename CompositeKey2><br>
+bool operator<(<br>
+ const composite_key_result<CompositeKey1>& x,<br>
+ const composite_key_result<CompositeKey2>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator<(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const std::tuple<Values...>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator<(<br>
+ const std::tuple<Values...>& x,<br>
+ const composite_key_result<CompositeKey>& y);<br>
+template<typename CompositeKey,typename Value0,...,typename Valuen><br>
+bool operator<(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const boost::tuple<Value0,...,Valuen>& y);<br>
+template<typename Value0,...,typename Valuen,typename CompositeKey><br>
+bool operator<(<br>
+ const boost::tuple<Value0,...,Valuen>& x,<br>
+ const composite_key_result<CompositeKey>& y);
+</code>
+
+<blockquote>
+<b>Requires:</b> The expressions
+<code>x<sub>i</sub><y<sub>i</sub></code> and
+<code>y<sub>i</sub><x<sub>i</sub></code> are valid for all <code>i</code>
+in <code>[0,min(length(x),length(y)))</code>.<br>
+<b>Returns:</b> <code>true</code> if and only if there exists some
+<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
+such that
+<blockquote>
+<code>!(x<sub>i</sub><y<sub>i</sub>) && !(y<sub>i</sub><x<sub>i</sub>)</code>
+for all <code>i</code> in <code>[0,j)</code>,<br>
+<code> x<sub>j</sub><y<sub>j</sub></code>.
+</blockquote>
+<b>Complexity:</b> No more key extraction operations and comparisons
+are performed than those necessary for the evaluation of the expression above,
+starting at <code>i==0</code>. The evaluation is short-circuited as soon as
+the result is determined to be <code>false</code>.
+</blockquote>
+
+<code>template<typename CompositeKey1,typename CompositeKey2><br>
+bool operator <b><i>OP</i></b>(<br>
+ const composite_key_result<CompositeKey1>& x,<br>
+ const composite_key_result<CompositeKey2>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator <b><i>OP</i></b>(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const std::tuple<Values...>& y);<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator <b><i>OP</i></b>(<br>
+ const std::tuple<Values...>& x,<br>
+ const composite_key_result<CompositeKey>& y);<br>
+template<typename CompositeKey,typename Value0,...,typename Valuen><br>
+bool operator <b><i>OP</i></b>(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const boost::tuple<Value0,...,Valuen>& y);<br>
+template<typename Value0,...,typename Valuen,typename CompositeKey><br>
+bool operator <b><i>OP</i></b>(<br>
+ const boost::tuple<Value0,...,Valuen>& x,<br>
+ const composite_key_result<CompositeKey>& y);
+</code>
+
+<p>
+(<code><b><i>OP</i></b></code> is any of <code>!=</code>, <code>></code>,
+<code>>=</code>, <code><=</code>.)
+</p>
+
+<blockquote>
+<b>Requires:</b> The expressions given below are valid (for the particular
+<code><b><i>OP</i></b></code> considered.)<br>
+<b>Returns:</b> <code>true</code> if and only if
+<blockquote>
+<code>!(x==y)</code> (<code><b><i>OP</i></b></code> is <code>!=</code>),<br>
+<code> y< x </code> (<code><b><i>OP</i></b></code> is <code>> </code>),<br>
+<code>!(x< y)</code> (<code><b><i>OP</i></b></code> is <code>>=</code>),<br>
+<code>!(y< x)</code> (<code><b><i>OP</i></b></code> is <code><=</code>).
+</blockquote>
+</blockquote>
+
+<h3><a name="ckey_result_equality">Equality</a></h3>
+
+<h4><a name="composite_key_equal_to">Class template
+<code>composite_key_equal_to</code></a></h4>
+
+<p>
+<code>composite_key_equal_to</code> tests for equality between
+<code>composite_key_result</code> instantiations and between
+these and tuples of values, using an internally stored
+collection of elementary equality predicates.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Pred0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Predn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_equal_to</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Pred0</span><span class=special>,...,</span><span class=identifier>Predn</span><span class=special>></span> <span class=identifier>key_eq_tuple</span><span class=special>;</span>
+
+ <span class=identifier>composite_key_equal_to</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>Pred0</span><span class=special>&</span> <span class=identifier>p0</span><span class=special>=</span><span class=identifier>Pred0</span><span class=special>(),</span>
+ <span class=special>...</span>
+ <span class=keyword>const</span> <span class=identifier>Predn</span><span class=special>&</span> <span class=identifier>pn</span><span class=special>=</span><span class=identifier>Predn</span><span class=special>());</span>
+
+ <span class=identifier>composite_key_equal_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_eq_tuple</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>const</span> <span class=identifier>key_eq_tuple</span><span class=special>&</span> <span class=identifier>key_eqs</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_eq_tuple</span><span class=special>&</span> <span class=identifier>key_eqs</span><span class=special>()</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>></span> <span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>></span> <span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>Pred0</code>, ... , <code>Predn</code> are the types of the equality
+binary predicates stored by <code>composite_key_equal_to</code>. Each of these predicates
+must be <code>CopyConstructible</code> and <code>CopyAssignable</code>. At least an
+equality predicate must be provided. The maximum number of equality predicates of
+a <code>composite_key_equal_to</code> instantiation is implementation defined.
+<code>composite_key_equal_to</code> is
+<code>CopyConstructible</code> and <code>CopyAssignable</code>.
+It is also <code>DefaultConstructible</code>
+if each <code>Predi</code> is <code>DefaultConstructible</code> in its turn.
+</p>
+
+<p>
+Note that formally it is not required that the <code>Predi</code> types
+behave as equality predicates in any definite way. However, the
+semantics of <code>composite_key_equal_to</code> is well defined if this
+is the case, as explained in the section on the
+<a href="#ckey_result_semantics">semantics of <code>composite_key_result</code></a>.
+</p>
+
+<h4>Notation</h4>
+
+<p>
+In what follows we use the same <a href="#ckey_result_notation">notation</a>
+introduced for <code>composite_key_result</code>.
+
+<h4><code>composite_key_equal_to</code> members</h4>
+
+<code>composite_key_equal_to(<br>
+ const Pred0& p0=Pred0(),<br>
+ ...<br>
+ const Predn& pn=Predn());
+</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_equal_to</code> that stores
+copies of the equality predicates supplied.
+</blockquote>
+
+<code>composite_key_equal_to(const key_eq_tuple& x);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_equal_to</code> that stores
+copies of the equality predicate objects supplied in <code>x</code>.
+</blockquote>
+
+<code>const key_eq_tuple& key_eqs()const;</code>
+
+<blockquote>
+<b>Returns:</b> a constant reference to a tuple holding the
+equality predicate objects internally stored by the
+<code>composite_key_equal_to</code>.
+</blockquote>
+
+<code>key_eq_tuple& key_eqs();</code>
+
+<blockquote>
+<b>Returns:</b> a reference to a tuple holding the
+equality predicate objects internally stored by the
+<code>composite_key_equal_to</code>.
+</blockquote>
+
+<code>
+template<typename CompositeKey1,typename CompositeKey2><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey1> & x,<br>
+ const composite_key_result<CompositeKey2> & y)const;<br>
+template<typename CompositeKey,typename Values...><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const std::tuple<Values...>& y)const;<br>
+template<typename CompositeKey,typename Values...><br>
+bool operator()(<br>
+ const std::tuple<Values...>& x,<br>
+ const composite_key_result<CompositeKey>& y)const;<br>
+template<typename CompositeKey,typename Value0,...,typename Valuen><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const boost::tuple<Value0,...,Valuen>& y)const;<br>
+template<typename Value0,...,typename Valuen,typename CompositeKey><br>
+bool operator()(<br>
+ const boost::tuple<Value0,...,Valuen>& x,<br>
+ const composite_key_result<CompositeKey>& y)const;<br>
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>length(x)==length(y)</code>. The expressions
+<code>key_eqs().get<i>()(x<sub>i</sub>,y<sub>i</sub>)</code> and
+<code>key_eqs().get<i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
+are valid for all <code>i</code> in <code>[0,length(x))</code>.<br>
+<b>Returns:</b> <code>true</code> if and only
+<blockquote>
+<code>key_eqs().get<i>()(x<sub>i</sub>,y<sub>i</sub>)</code>
+for all <code>i</code> in <code>[0,length(x))</code>.<br>
+</blockquote>
+<b>Complexity:</b> No more key extraction operations and comparisons
+are performed than those necessary for the evaluation of the expression above,
+starting at <code>i==0</code>. The evaluation is short-circuited as soon as
+the result is determined to be <code>false</code>.
+</blockquote>
+
+<h4><a name="composite_key_result_equal_to">Class template
+<code>composite_key_result_equal_to</code></a></h4>
+
+<p>
+Deprecated. Use <code>std::equal_to<CompositeKeyResult></code> instead.
+</p>
+
+<h4><a name="equal_to_composite_key_result">Specialization of
+<code>std::equal_to</code> for <code>composite_key</code> results</a></h4>
+
+<p>
+<code>std::equal_to<CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
+an instantiation of <code>composite_key_result</code>,
+behaves as a particularization of
+<code>composite_key_equal_to</code> where all the comparison predicates supplied
+are instantiations of <code>std::equal_to</code>.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>equal_to</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span>
+ <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span>
+ <span class=identifier>CompositeKey</span><span class=special>></span> <span class=identifier>first_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>></span> <span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>></span> <span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=special>}</span> <span class=comment>// namespace std</span>
+</pre></blockquote>
+
+<p>
+<code>CompositeKeyResult</code> must be an instantiation of
+<code>composite_key_result</code> for some type
+<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
+<code>std::equal:to<CompositeKeyResult>::operator()</code> is
+then equivalent to
+<code>composite_key_equal_to<Pred0,...,Predn>::operator()</code>, taking
+<blockquote>
+<code>Predi = std::equal_to<KeyFromValuei::result_type></code> for all
+<code>i = 0,...,n</code>.
+</blockquote>
+</p>
+
+<p>
+In addition to the requirements on <code>Predi</code> imposed by
+<code>composite_key_equal_to</code>, each of these types must be
+<code>DefaultConstructible</code>. <code>std::equal_to<CompositeKeyResult></code>
+is <code>DefaultConstructible</code>, <code>CopyConstructible</code> and
+<code>CopyAssignable</code>.
+</p>
+
+<h3><a name="ckey_result_comparison">Comparison</a></h3>
+
+<h4><a name="composite_key_compare">Class template
+<code>composite_key_compare</code></a></h4>
+
+<p>
+<code>composite_key_compare</code> compares <code>composite_key_result</code>
+instantiations between them and with tuples of values using an internally stored
+collection of elementary comparison predicates.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Comparen</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Compare0</span><span class=special>,...,</span><span class=identifier>Comparen</span><span class=special>></span> <span class=identifier>key_comp_tuple</span><span class=special>;</span>
+
+ <span class=identifier>composite_key_compare</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>Compare0</span><span class=special>&</span> <span class=identifier>c0</span><span class=special>=</span><span class=identifier>Compare0</span><span class=special>(),</span>
+ <span class=special>...</span>
+ <span class=keyword>const</span> <span class=identifier>Comparen</span><span class=special>&</span> <span class=identifier>cn</span><span class=special>=</span><span class=identifier>Comparen</span><span class=special>());</span>
+
+ <span class=identifier>composite_key_compare</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_comp_tuple</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>const</span> <span class=identifier>key_comp_tuple</span><span class=special>&</span> <span class=identifier>key_comps</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_comp_tuple</span><span class=special>&</span> <span class=identifier>key_comps</span><span class=special>()</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>></span> <span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>></span> <span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>Compare0</code>, ... , <code>Comparen</code> are the types of the comparison
+binary predicates stored by <code>composite_key_compare</code>. Each of these predicates must be
+<code>CopyConstructible</code> and <code>CopyAssignable</code>. At least a
+comparison predicate must be provided. The maximum number of comparison predicates of
+a <code>composite_key_compare</code> instantiation is implementation defined.
+<code>composite_key_compare</code> is
+<code>CopyConstructible</code> and <code>CopyAssignable</code>.
+It is also
+<code>DefaultConstructible</code>
+if each <code>Comparei</code> is <code>DefaultConstructible</code> in its turn.
+</p>
+
+<p>
+Note that formally it is not required that the <code>Comparei</code> types
+behave as comparison predicates in any definite way. However, the
+semantics of <code>composite_key_compare</code> is well defined if this
+is the case, as explained in the section on the
+<a href="#ckey_result_semantics">semantics of <code>composite_key_result</code></a>.
+</p>
+
+<h4>Notation</h4>
+
+<p>
+In what follows we use the same <a href="#ckey_result_notation">notation</a>
+introduced for <code>composite_key_result</code>.
+
+<h4><code>composite_key_compare</code> members</h4>
+
+<code>composite_key_compare(<br>
+ const Compare0& c0=Compare0(),<br>
+ ...<br>
+ const Comparen& cn=Comparen());
+</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
+copies of the comparison predicates supplied.
+</blockquote>
+
+<code>composite_key_compare(const key_comp_tuple& x);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
+copies of the comparison predicate objects supplied in <code>x</code>.
+</blockquote>
+
+<code>const key_comp_tuple& key_comps()const;</code>
+
+<blockquote>
+<b>Returns:</b> a constant reference to a tuple holding the
+comparison predicate objects internally stored by the
+<code>composite_key_compare</code>.
+</blockquote>
+
+<code>key_comp_tuple& key_comps();</code>
+
+<blockquote>
+<b>Returns:</b> a reference to a tuple holding the
+comparison predicate objects internally stored by the
+<code>composite_key_compare</code>.
+</blockquote>
+
+<code>
+template<typename CompositeKey1,typename CompositeKey2><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey1> & x,<br>
+ const composite_key_result<CompositeKey2> & y)const;<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const std::tuple<Values...>& y)const;<br>
+template<typename CompositeKey,typename... Values><br>
+bool operator()(<br>
+ const std::tuple<Values...>& x,<br>
+ const composite_key_result<CompositeKey>& y)const;<br>
+template<typename CompositeKey,typename Value0,...,typename Valuen><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x,<br>
+ const boost::tuple<Value0,...,Valuen>& y)const;<br>
+template<typename Value0,...,typename Valuen,typename CompositeKey><br>
+bool operator()(<br>
+ const boost::tuple<Value0,...,Valuen>& x,<br>
+ const composite_key_result<CompositeKey>& y)const;<br>
+</code>
+
+<blockquote>
+<b>Requires:</b> The expressions
+<code>key_comps().get<i>()(x<sub>i</sub>,y<sub>i</sub>)</code> and
+<code>key_comps().get<i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
+are valid for all <code>i</code>
+in <code>[0,min(length(x),length(y)))</code>.<br>
+<b>Returns:</b> <code>true</code> if and only if there exists some
+<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
+such that
+<blockquote>
+<code>!key_comps().get<i>()(x<sub>i</sub>,y<sub>i</sub>) && !key_comps().get<i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
+for all <code>i</code> in <code>[0,j)</code>,<br>
+<code> key_comps().get<j>()(x<sub>j</sub>,y<sub>j</sub>)</code>.
+</blockquote>
+<b>Complexity:</b> No more key extraction operations and comparisons
+are performed than those necessary for the evaluation of the expression above,
+starting at <code>i==0</code>. The evaluation is short-circuited as soon as
+the result is determined to be <code>false</code>.
+</blockquote>
+
+<code>
+template<typename CompositeKey,typename Value><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x,const Value& y)const;
+</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=keyword>return</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>x</span><span class=special>,</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>make_tuple</span><span class=special>(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>cref</span><span class=special>(</span><span class=identifier>y</span><span class=special>)));</span>
+</pre></blockquote><br>
+</blockquote>
+
+<code>
+template<typename Value,typename CompositeKey><br>
+bool operator()(<br>
+ const Value& x,const composite_key_result<CompositeKey>& y)const;
+</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=keyword>return</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>make_tuple</span><span class=special>(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>cref</span><span class=special>(</span><span class=identifier>x</span><span class=special>)),</span><span class=identifier>y</span><span class=special>);</span>
+</pre></blockquote><br>
+</blockquote>
+
+<h4><a name="composite_key_result_less">Class template
+<code>composite_key_result_less</code></a></h4>
+
+<p>
+Deprecated. Use <code>std::less<CompositeKeyResult></code> instead.
+</p>
+
+<h4><a name="composite_key_result_greater">Class template
+<code>composite_key_result_greater</code></a></h4>
+
+<p>
+Deprecated. Use <code>std::greater<CompositeKeyResult></code> instead.
+</p>
+
+<h4><a name="less_composite_key_result">Specialization of <code>std::less</code> for
+<code>composite_key</code> results</a></h4>
+
+<p>
+<code>std::less<CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
+an instantiation of <code>composite_key_result</code>, behaves as a particularization of
+<code>composite_key_compare</code> where all the comparison predicates supplied are
+instantiations of <code>std::less</code>.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>less</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span>
+ <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span>
+ <span class=identifier>CompositeKey</span><span class=special>></span> <span class=identifier>first_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>></span> <span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>></span> <span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=special>}</span> <span class=comment>// namespace std</span>
+</pre></blockquote>
+
+<p>
+<code>CompositeKeyResult</code> must be an instantiation of
+<code>composite_key_result</code> for some type
+<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
+<code>std::less<CompositeKeyResult>::operator()</code> is
+then equivalent to
+<code>composite_key_compare<Compare0,...,Comparen>::operator()</code>, taking
+<blockquote>
+<code>Comparei = std::less<KeyFromValuei::result_type></code> for all
+<code>i = 0,...,n</code>.
+</blockquote>
+</p>
+
+<p>
+In addition to the requirements on <code>Comparei</code> imposed by
+<code>composite_key_compare</code>, each of these types must be
+<code>DefaultConstructible</code>. <code>std::less<CompositeKeyResult></code>
+is <code>CopyConstructible</code>, <code>CopyConstructible</code>
+and <code>CopyAssignable</code>.
+</p>
+
+<h4><a name="greater_composite_key_result">Specialization of <code>std::greater</code> for
+<code>composite_key</code> results</a></h4>
+
+<p>
+<code>std::greater<CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
+an instantiation of <code>composite_key_result</code>, behaves as a particularization of
+<code>composite_key_compare</code> where all the comparison predicates supplied
+are instantiations of <code>std::greater</code>.
+</p>
+
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>greater</span><span class=special><</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span>
+ <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span>
+ <span class=identifier>CompositeKey</span><span class=special>></span> <span class=identifier>first_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey1</span><span class=special>></span> <span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey2</span><span class=special>></span> <span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=special>}</span> <span class=comment>// namespace std</span>
+</pre></blockquote>
+
+<p>
+<code>CompositeKeyResult</code> must be an instantiation of
+<code>composite_key_result</code> for some type
+<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
+<code>std::greater<CompositeKeyResult>::operator()</code> is
+then equivalent to
+<code>composite_key_compare<Compare0,...,Comparen>::operator()</code>, taking
+<blockquote>
+<code>Comparei = std::greater<KeyFromValuei::result_type></code> for all
+<code>i = 0,...,n</code>.
+</blockquote>
+</p>
+
+<p>
+In addition to the requirements on <code>Comparei</code> imposed by
+<code>composite_key_compare</code>, each of these types must be
+<code>DefaultConstructible</code>. <code>std::greater<CompositeKeyResult></code>
+is <code>CopyConstructible</code>, <code>CopyConstructible</code>
+and <code>CopyAssignable</code>.
+</p>
+
+<h3><a name="ckey_result_hashing">Hashing</a></h3>
+
+<h4><a name="composite_key_hash">Class template
+<code>composite_key_hash</code></a></h4>
+
+<p>
+<code>composite_key_hash</code> produces hash values for <code>composite_key_result</code>
+instantiations based on a collection of elementary hash functors.
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Hash0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Hashn</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>composite_key_hash</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Hash0</span><span class=special>,...,</span><span class=identifier>Hashn</span><span class=special>></span> <span class=identifier>key_hasher_tuple</span><span class=special>;</span>
+
+ <span class=identifier>composite_key_hash</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>Hash0</span><span class=special>&</span> <span class=identifier>h0</span><span class=special>=</span><span class=identifier>Hash0</span><span class=special>(),</span>
+ <span class=special>...</span>
+ <span class=keyword>const</span> <span class=identifier>Hashn</span><span class=special>&</span> <span class=identifier>hn</span><span class=special>=</span><span class=identifier>Hashn</span><span class=special>());</span>
+
+ <span class=identifier>composite_key_hash</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_hasher_tuple</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>const</span> <span class=identifier>key_hasher_tuple</span><span class=special>&</span> <span class=identifier>key_hash_functions</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_hasher_tuple</span><span class=special>&</span> <span class=identifier>key_hash_functions</span><span class=special>()</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+</pre></blockquote>
+
+<p>
+<code>Hash0</code>, ... , <code>Hashn</code> are the types of the hash unary function objects
+stored by <code>composite_key_hash</code>. Each of these objects
+must be <code>CopyConstructible</code> and <code>CopyAssignable</code>
+and return a value of type <code>std::size_t</code> in the range
+[0, <code>std::numeric_limits<std::size_t>::max())</code>).
+At least a hash functor must be provided. The maximum number of hash functors of
+a <code>composite_key_hash</code> instantiation is implementation defined.
+<code>composite_key_hash</code> is
+<code>CopyConstructible</code> and <code>CopyAssignable</code>.
+It is also <code>DefaultConstructible</code>
+if each <code>Hashi</code> is <code>DefaultConstructible</code> in its turn.
+</p>
+
+<h4>Notation</h4>
+
+<p>
+In what follows we use the same <a href="#ckey_result_notation">notation</a>
+introduced for <code>composite_key_result</code>.
+
+<h4><code>composite_key_hash</code> members</h4>
+
+<code>composite_key_hash(<br>
+ const Hash0& h0=Hash0(),<br>
+ ...<br>
+ const Hashn& hn=Hashn());
+</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_hash</code> that stores
+copies of the hash functors supplied.
+</blockquote>
+
+<code>composite_key_hash(const key_hasher_tuple& x);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>composite_key_hash</code> that stores
+copies of the hash functors supplied in <code>x</code>.
+</blockquote>
+
+<code>const key_hasher_tuple& key_hash_functions()const;</code>
+
+<blockquote>
+<b>Returns:</b> a constant reference to a tuple holding the
+hash functors internally stored by the
+<code>composite_key_hash</code>.
+</blockquote>
+
+<code>key_hasher_tuple& key_hash_functions();</code>
+
+<blockquote>
+<b>Returns:</b> a reference to a tuple holding the
+hash functors internally stored by the
+<code>composite_key_hash</code>.
+</blockquote>
+
+<code>
+template<typename CompositeKey><br>
+bool operator()(<br>
+ const composite_key_result<CompositeKey>& x)const;<br>
+template<typename... Values><br>
+bool operator()(<br>
+ const std::tuple<Values...>& x)const;<br>
+template<typename Value0,...,typename Valuen><br>
+bool operator()(<br>
+ const boost::tuple<Value0,...,Valuen>& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>length(x)==length(key_hash_functions())</code>.
+The expression
+<code>key_hash_functions().get<i>()(x<sub>i</sub>)</code>
+is valid for all <code>i</code> in <code>[0,length(x))</code>.
+<br>
+<b>Returns:</b> A value in the range
+<code>[0, std::numeric_limits<std::size_t>::max())</code> that
+solely depends on the numerical tuple
+<blockquote>
+(<code>key_hash_functions().get<0>()(x<sub>0</sub>)</code>, ... ,
+<code>key_hash_functions().get<N>()(x<sub>N</sub>)</code>),
+with <code>N=length(x)-1</code>.
+</blockquote>
+</blockquote>
+
+<h4><a name="composite_key_result_hash">Class template
+<code>composite_key_result_hash</code></a></h4>
+
+<p>
+Deprecated. Use <code>boost::hash<CompositeKeyResult></code> instead.
+</p>
+
+<h4><a name="hash_composite_key_result">Specialization of
+<a href="../../../functional/hash/index.html"><code>boost::hash</code></a>
+for <code>composite_key</code> results</a></h4>
+
+<p>
+<code>boost::hash<CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
+an instantiation of <code>composite_key_result</code>, behaves as a particularization of
+<code>composite_key_hash</code> where all the hash functors supplied
+are instantiations of
+<a href="../../../functional/hash/index.html"><code>boost::hash</code></a>.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>hash</span><span class=special><</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=special>></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>></span> <span class=identifier>argument_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>result_type</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special><</span><span class=identifier>CompositeKey</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Values</span><span class=special>...>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
+ <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>CompositeKeyResult</code> must be an instantiation of
+<code>composite_key_result</code> for some type
+<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
+<code>boost::hash<CompositeKeyResult>::operator()</code> is
+then equivalent to
+<code>composite_key_hash<Hash0,...,Hashn>::operator()</code>, taking
+<blockquote>
+<code>Hashi = boost::hash<KeyFromValuei::result_type></code> for all
+<code>i = 0,...,n</code>.
+</blockquote>
+</p>
+
+<p>
+In addition to the requirements on <code>Hashi</code> imposed by
+<code>composite_key_hash</code>, each of these types must be
+<code>DefaultConstructible</code>. <code>boost::hash<CompositeKeyResult></code> is
+<code>DefaultConstructible</code>, <code>CopyConstructible</code>
+and <code>CopyAssignable</code>.
+</p>
+
+<h3><a name="ckey_result_semantics">Semantics of
+<code>composite_key_result</code></a></h3>
+
+<p>
+The design of equality, comparison and hash operations for
+<code>composite_key_result</code> objects is based on the following rationale:
+a <code>composite_key_result</code> is regarded as a "virtual" tuple, each
+of its elements being the result of the corresponding elementary
+key extractor. Accordingly, any given operation resolves to a
+combination of the corresponding elementwise operations.
+This mapping preserves the fundamental properties of the elementary operations
+involved; for instance, it defines a true equivalence relation if the
+basic predicates induce equivalence relations themselves.
+We can state these facts in a formal way as follows.
+</p>
+
+<p>
+Consider an instantiation of <code>composite_key_equal_to</code>
+with types <code>Pred0</code>, ... , <code>Predn</code> such that each
+<code>Predi</code> induces an equivalence relation on a certain type <code>Ti</code>,
+and let <code>CompositeKey</code> be a type of the form
+<code>composite_key<Value,KeyFromValue0,...,KeyFromValuej></code>,
+with <code>j <= n</code>, such that
+<blockquote>
+<code>KeyFromValuei::result_type = Ti</code>, for all <code>i = 0,...,j</code>.
+</blockquote>
+Then, <code>composite_key_equal_to</code> induces an equivalence relation
+on elements of type <code>composite_key_result<CompositeKey></code>;
+such two objects are equivalent if all its elementary key extractor values
+are also equivalent. Additionally, given an instantiation
+<code>composite_key_hash<Hash0,...,Hashj></code>, the following types are
+<a href="hash_indices.html#lookup"><code>Compatible Keys</code></a> of
+(<code>composite_key_hash</code>, <code>composite_key_equal_to</code>)
+with respect to <code>composite_key_result<CompositeKey></code>:
+<blockquote>
+<code>tuple<Q0,...,Qj></code>,<br>
+<code>composite_key_result<composite_key<K0,...,Kj> ></code>, with
+<code>Ki::result_type = Qi</code> for all <code>i = 0,...,j</code>.
+</blockquote>
+provided that each <code>Qi</code> is either <code>Ti</code> or a
+<a href="hash_indices.html#lookup"><code>Compatible Key</code></a>
+of (<code>Hashi</code>, <code>Predi</code>).</p>
+
+<p>
+As for comparison, consider an instantiation of <code>composite_key_compare</code>
+with types <code>Compare0</code>, ... , <code>Comparen</code> such that each
+<code>Comparei</code> induces a strict weak ordering
+on the type <code>Ti</code>. Then, for a
+<code>CompositeKey</code> type defined in the same manner as above,
+<code>composite_key_compare</code> induces a strict weak ordering on elements of type
+<code>composite_key_result<CompositeKey></code>, and the order induced
+is lexicographical. Also, the following types are
+<a href="ord_indices.html#set_operations"><code>Compatible Keys</code></a> of
+<code>composite_key_compare</code> with respect to
+<code>composite_key_result<CompositeKey></code>:
+<blockquote>
+<code>tuple<Q0,...,Qk></code>, <code>k <= n</code><br>
+<code>composite_key_result<composite_key<K0,...,Kk> ></code>, with
+<code>Ki::result_type = Qi</code> for all <code>i = 0,...,k</code>.
+</blockquote>
+provided that
+<ul>
+ <li>for <code>i = 0,...,min(j,k)-1</code>, <code>Qi</code> is either <code>Ti</code>
+ or <i>not coarser</i> than <code>Ti</code> (<code>Qi</code> is a
+ <a href="ord_indices.html#set_operations"><code>Compatible Key</code></a>
+ of <code>Comparei</code> and there are no two distinct elements of
+ <code>Ti</code> equivalent to one single element of <code>Qi</code>);
+ </li>
+ <li>
+ <code>Qm</code> (with <code>m = min(j,k)</code>) is either <code>Tm</code> or a
+ <a href="ord_indices.html#set_operations"><code>Compatible Key</code></a>
+ of <code>Comparem</code>.
+ </li>
+</ul>
+
+In this case, the comparison is done
+lexicographically only on the first <code>1+min(j,k)</code> elements.
+</p>
+
+<p>
+Analogous properties hold for the equality and comparison operators
+of <code>composite_key_result</code>. Note, however,
+that equality is only defined for objects of the same length, whilst
+comparison takes the minimum length of the operands considered.
+Therefore, the equivalence classes induced by <code>x==y</code> are
+subsets of those associated to <code>!(x<y)&&!(y<x)</code>.
+</p>
+
+<hr>
+
+<div class="prev_link"><a href="rnd_indices.html"><img src="../prev.gif" alt="random access indices" border="0"><br>
+Random access indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
+Compiler specifics
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised November 24th 2015</p>
+
+<p>© Copyright 2003-2015 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/multi_index_container.html b/doc/reference/multi_index_container.html
new file mode 100644
index 0000000..5648ac9
--- /dev/null
+++ b/doc/reference/multi_index_container.html
@@ -0,0 +1,1014 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - multi_index_container reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="index.html">
+<link rel="up" href="index.html">
+<link rel="next" href="indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex
+<code>multi_index_container</code> reference</h1>
+
+<div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
+Index reference
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#multi_index_container_fwd_synopsis">Header
+ <code>"boost/multi_index_container_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index_container.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#multi_index_container">Class template <code>multi_index_container</code></a>
+ <ul>
+ <li><a href="#complexity">Complexity</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#types">Nested types</a></li>
+ <li><a href="#nested_templates">Nested class templates</a></li>
+ <li><a href="#constructors">Constructors, copy and assignment</a></li>
+ <li><a href="#index_retrieval">Index retrieval operations</a></li>
+ <li><a href="#projection">Projection operations</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="multi_index_container_fwd_synopsis">Header
+<a href="../../../../boost/multi_index_container_fwd.hpp"><code>"boost/multi_index_container_fwd.hpp"</code></a>
+synopsis</a>
+</h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>=</span><span class=identifier>indexed_by</span><span class=special><</span><span class=identifier>ordered_unique</span><span class=special><</span><span class=identifier>identity</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=special>></span> <span class=special>>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>allocator</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=special>></span>
+<span class=keyword>class</span> <span class=identifier>multi_index_container</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>multi_index_container</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>multi_index_container_fwd.hpp</code> forward declares the class template
+<a href="#multi_index_container"><code>multi_index_container</code></a> and specifies its default parameters.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index_container.hpp"><code>"boost/multi_index_container.hpp"</code></a>
+synopsis</a>
+</h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>></span>
+<span class=keyword>class</span> <span class=identifier>multi_index_container</span><span class=special>;</span>
+
+<span class=comment>// multi_index_container associated global class templates:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span> <span class=keyword>struct</span> <span class=identifier>nth_index</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span> <span class=keyword>struct</span> <span class=identifier>index</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>index_iterator</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>index_const_iterator</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
+
+<span class=comment>// multi_index_container global functions for index retrieval:</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+<span class=comment>// multi_index_container global functions for projection of iterators:</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+
+<span class=comment>// comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Value1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator1</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator2</span>
+<span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value1</span><span class=special>,</span><span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=identifier>Allocator1</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value2</span><span class=special>,</span><span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=identifier>Allocator2</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>multi_index_container</span><span class=special>;</span>
+<span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>get</span><span class=special>;</span>
+<span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>project</span><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="multi_index_container">
+Class template <code>multi_index_container</code>
+</a></h3>
+
+<p>
+This is the main component of Boost.MultiIndex. A <code>multi_index_container</code>
+is a container class template holding a compile-time user-defined list of
+<a href="indices.html">indices</a>. These indices provide different interfaces
+for the management of the elements of the <code>multi_index_container</code>. By itself,
+<code>multi_index_container</code> only provides basic functionality for construction
+and for access to the indices held.
+</p>
+
+<p>
+A <code>multi_index_container</code> type is instantiated with the type of the
+elements contained and a non-empty
+<a href="../../../../libs/mpl/doc/refmanual/forward-sequence.html">
+<code>MPL Forward Sequence</code></a> specifying which indices conform the
+class.
+</p>
+
+<p>
+For convenience of use, all public methods and types of the first index
+specified are inherited by <code>multi_index_container</code>. This also includes global
+operators and functions associated with the index (vg. comparison and
+<code>swap</code>.)
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>=</span><span class=identifier>indexed_by</span><span class=special><</span><span class=identifier>ordered_unique</span><span class=special><</span><span class=identifier>identity</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=special>></span> <span class=special>>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>allocator</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=special>></span>
+<span class=keyword>class</span> <span class=identifier>multi_index_container</span>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>ctor_args_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>index_specifier_type_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>index_type_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>iterator_type_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>const_iterator_type_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+
+ <span class=comment>// nested class templates:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>nth_index</span> <span class=special>{</span><span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>type</span><span class=special>;};</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>index</span> <span class=special>{</span><span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>type</span><span class=special>;};</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span> <span class=comment><b>// deprecated</b></span>
+ <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
+ <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>index_iterator</span> <span class=comment><b>// deprecated</b></span>
+ <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+ <span class=keyword>struct</span> <span class=identifier>index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
+ <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
+
+ <span class=comment>// construct/copy/destroy:</span>
+
+ <span class=identifier>multi_index_container</span><span class=special>();</span>
+ <span class=keyword>explicit</span> <span class=identifier>multi_index_container</span><span class=special>(
+ </span><span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&</span> <span class=identifier>args_list</span><span class=special>,
+ </span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
+ <span class=keyword>explicit</span> <span class=identifier>multi_index_container</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&</span> <span class=identifier>al</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=identifier>multi_index_container</span><span class=special>(</span>
+ <span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&</span> <span class=identifier>args_list</span><span class=special>=</span><span class=identifier>ctor_args_list</span><span class=special>(),
+ </span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
+ <span class=identifier>multi_index_container</span><span class=special>(</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=identifier>list</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&</span> <span class=identifier>args_list</span><span class=special>=</span><span class=identifier>ctor_args_list</span><span class=special>(),</span>
+ <span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
+ <span class=identifier>multi_index_container</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>multi_index_container</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=special>~</span><span class=identifier>multi_index_container</span><span class=special>();</span>
+
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=keyword>operator</span><span class=special>=(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=keyword>operator</span><span class=special>=(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=keyword>operator</span><span class=special>=(</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>Value</span><span class=special>></span> <span class=identifier>list</span><span class=special>)</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// retrieval of indices</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span><span class=special>&</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span> <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span><span class=special>&</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span><span class=special>&</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span> <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span><span class=special>&</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// projection of iterators</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>></span>
+ <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>></span>
+ <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>></span>
+ <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>></span>
+ <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=comment>// multi_index_container associated global class templates:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span> <span class=keyword>struct</span> <span class=identifier>nth_index</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span> <span class=keyword>struct</span> <span class=identifier>index</span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span> <span class=comment><b>// deprecated</b></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index_iterator</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index_const_iterator</span><span class=special><</span><span class=identifier>N</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>index_iterator</span> <span class=comment><b>// deprecated</b></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index_iterator</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
+<span class=special>{</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index_const_iterator</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=comment>// multi_index_container global functions for index retrieval:</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special><</span><span class=identifier>N</span><span class=special>>();</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special><</span><span class=identifier>N</span><span class=special>>();</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>();</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>&</span>
+<span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>();</span>
+<span class=special>}</span>
+
+<span class=comment>// multi_index_container global functions for projection of iterators:</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special><</span><span class=identifier>N</span><span class=special>>(</span><span class=identifier>it</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>N</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special><</span><span class=identifier>N</span><span class=special>>(</span><span class=identifier>it</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>(</span><span class=identifier>it</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
+<span class=special>></span>
+<span class=keyword>typename</span> <span class=identifier>index</span><span class=special><</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span><span class=identifier>Tag</span>
+<span class=special>>::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
+<span class=identifier>project</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>m</span><span class=special>,</span>
+ <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special><</span><span class=identifier>Tag</span><span class=special>>(</span><span class=identifier>it</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>Value1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator1</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Value2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator2</span>
+<span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value1</span><span class=special>,</span><span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=identifier>Allocator1</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value2</span><span class=special>,</span><span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=identifier>Allocator2</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+ <span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>get</span><span class=special><</span><span class=number>0</span><span class=special>>(</span><span class=identifier>x</span><span class=special>)</span> <b><i>OP</i></b> <span class=identifier>get</span><span class=special><</span><span class=number>0</span><span class=special>>(</span><span class=identifier>y</span><span class=special>);</span>
+ <span class=special>}</span>
+
+<span class=comment>// specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=identifier>multi_index_container</span><span class=special><</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+ <span class=special>{</span>
+ <span class=identifier>x</span><span class=special>.</span><span class=identifier>swap</span><span class=special>(</span><span class=identifier>y</span><span class=special>);</span>
+ <span class=special>}</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity">Complexity</a></h4>
+
+<p>
+In the descriptions of operations of <code>multi_index_container</code>, we adopt the
+scheme outlined in the
+<a href="indices.html#complexity_signature">complexity signature section</a>.
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>
+<code>multi_index_container</code> is instantiated with the following types:
+<ol>
+ <li><code>Value</code> is the type of the elements contained. <code>Value</code> must be
+ <code>Erasable</code> from <code>multi_index_container</code>.
+ </li>
+ <li><code>IndexSpecifierList</code> specifies the indices that the
+ <code>multi_index_container</code> is composed of. It must be a non-empty
+ <a href="../../../../libs/mpl/doc/refmanual/forward-sequence.html">
+ <code>MPL Forward Sequence</code></a> (and, preferrably,
+ an <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+ <code>MPL Random Access Sequence</code></a>) of index specifiers. For
+ syntactic convenience, the
+ <a href="indices.html#indexed_by"><code>indexed_by</code></a>
+ MPL sequence can be used.
+ </li>
+ <li><code>Allocator</code> must be an allocator of <code>Value</code> objects
+ satisfying the associated C++ requirements at <b>[allocator.requirements]</b>.
+ The following relaxations to the standard requirements are allowed:
+ <ul>
+ <li>Non-equal allocator instances are supported: swapping two non-equal
+ instances must not throw any exception.
+ </li>
+ <li>For every type <code>T</code>,
+ the type <code>Allocator::rebind<T>::other::pointer</code> can be any
+ kind of random access iterator, provided that it is explicitly constructible from
+ the literal <code>0</code> (standing here as the null pointer) or from any
+ <code>p</code> of type <code>T*</code> pointing into an area allocated by
+ some instance of <code>Allocator</code> or some other allocator type rebound
+ from <code>Allocator</code>. A <code>pointer</code> constructed from
+ <code>p</code> shall dereference to <code>*p</code>.
+ </li>
+ </ul>
+ </li>
+</ol>
+Indices of a given <code>multi_index_container</code> instantiation cannot have
+duplicate <a href="indices.html#tags">tags</a>, either within a single
+index or in two different indices.
+</p>
+
+<h4><a name="types">Nested types</a></h4>
+
+<code>ctor_args_list</code>
+
+<blockquote>
+Although the exact definition of <code>ctor_args_list</code> is
+implementation defined, from the user point of view this type can be
+treated as equivalent to
+<code>::boost::tuple<C<sub>0</sub>,...,C<sub>I-1</sub>></code>,
+where <code>C<sub>i</sub></code> is the <code>ctor_args</code> type of the
+<code>i</code>-th index held by the <code>multi_index_container</code>, in the
+same order as they were specified. Strictly speaking, there is an
+implicit conversion from
+<code>const ::boost::tuple<C<sub>0</sub>,...,C<sub>I-1</sub>>&</code>
+to <code>const ctor_args_list&</code>. This type is used for
+providing the construction arguments of the indices of the
+<code>multi_index_container</code>. <code>ctor_args_list</code> is
+<code>DefaultConstructible</code>, provided that all <code>ctor_args</code> types
+involved are <code>DefaultConstructible</code>.
+</blockquote>
+
+<code>index_specifier_type_list</code>
+
+<blockquote>
+Same type as <code>IndexSpecifierList</code>.
+</blockquote>
+
+<code>index_type_list</code>
+
+<blockquote>
+Model of
+<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+<code>MPL Random Access Sequence</code></a> and
+<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
+<code>MPL Extensible Sequence</code></a> containing the types of the indices held by
+the <code>multi_index_container</code>, in the same order as they were specified.
+</blockquote>
+
+<code>iterator_type_list</code>
+
+<blockquote>
+Model of
+<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+<code>MPL Random Access Sequence</code></a> and
+<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
+<code>MPL Extensible Sequence</code></a> containing the types of the iterators of
+the indices held by the <code>multi_index_container</code>, in the same order as they were
+specified.
+</blockquote>
+
+<code>const_iterator_type_list</code>
+
+<blockquote>
+Model of
+<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
+<code>MPL Random Access Sequence</code></a> and
+<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
+<code>MPL Extensible Sequence</code></a> containing the types of the constant
+iterators of the indices held by the <code>multi_index_container</code>, in the same order
+as they were specified.
+</blockquote>
+
+<h4><a name="nested_templates">Nested class templates</a></h4>
+
+<code>template<int N> struct nth_index</code>
+
+<blockquote>
+<code>nth_index<N>::type</code> yields the type of the
+<code>N</code>-th (0-based) index held by the <code>multi_index_container</code>, in
+the same order as they were specified.<br>
+<b>Requires:</b> <code>0 <= N < I</code>.
+</blockquote>
+
+<code>template<typename Tag> struct index</code>
+
+<blockquote>
+<code>index<Tag>::type</code> yields the type of the index which
+has <code>Tag</code> as an associated <a href="indices.html#tags">tag type</a>.<br>
+<b>Requires:</b> Some index of the <code>multi_index_container</code> has <code>Tag</code>
+as an associated tag type.
+</blockquote>
+
+<code>template<int N> struct nth_index_iterator</code>
+
+<blockquote>
+<code>nth_index_iterator<N>::type</code> is equivalent to
+<code>nth_index<N>::type::iterator</code>.<br>
+<b>Note:</b> The use of <code>nth_index_iterator</code> is deprecated.
+</blockquote>
+
+<code>template<int N> struct nth_index_const_iterator</code>
+
+<blockquote>
+<code>nth_index_const_iterator<N>::type</code> is equivalent to
+<code>nth_index<N>::type::const_iterator</code>.<br>
+<b>Note:</b> The use of <code>nth_index_const_iterator</code> is deprecated.
+</blockquote>
+
+<code>template<typename Tag> struct index_iterator</code>
+
+<blockquote>
+<code>index_iterator<Tag>::type</code> is equivalent to
+<code>index<Tag>::type::iterator</code>.<br>
+<b>Note:</b> The use of <code>index_iterator</code> is deprecated.
+</blockquote>
+
+<code>template<typename Tag> struct index_const_iterator</code>
+
+<blockquote>
+<code>index_const_iterator<Tag>::type</code> is equivalent to
+<code>index<Tag>::type::const_iterator</code>.<br>
+<b>Note:</b> The use of <code>index_const_iterator</code> is deprecated.
+</blockquote>
+
+<h4><a name="constructors">Constructors, copy and assignment</a></h4>
+
+<code>multi_index_container();</code>
+
+<blockquote>
+<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
+default values of <code>ctor_args_list</code> and <code>allocator_type</code>.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<code>explicit multi_index_container(<br>
+ const ctor_args_list& args_list,<br>
+ const allocator_type& al=allocator_type());</code>
+
+<blockquote>
+<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
+specified argument list and allocator.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<code>explicit multi_index_container(const allocator_type& al);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
+specified allocator and the default value of <code>ctor_args_list</code>.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<code>template<typename InputIterator><br>
+multi_index_container(<br>
+ InputIterator first,InputIterator last,<br>
+ const ctor_args_list& args_list=ctor_args_list(),<br>
+ const allocator_type& al=allocator_type());</code>
+
+<blockquote>
+<b>Requires:</b> <code>InputIterator</code> is an input iterator.
+<code>Value</code> is
+<code>EmplaceConstructible</code> into <code>multi_index_container</code>
+from <code>*first</code>.
+<code>last</code> is reachable from <code>first</code>.<br>
+<b>Effects:</b> Constructs and empty <code>multi_index_container</code> using the
+specified argument list and allocator and fills it with
+the elements in the range [<code>first</code>,<code>last</code>).
+Insertion of each element may or may not succeed depending
+on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
+<b>Complexity:</b> <code>O(m*H(m))</code>, where <code>m</code> is
+the number of elements in [<code>first</code>,<code>last</code>).<br>
+</blockquote>
+
+<code>multi_index_container(<br>
+ std::initializer_list<Value> list,<br>
+ const ctor_args_list& args_list=ctor_args_list(),<br>
+ const allocator_type& al=allocator_type());</code>
+
+<blockquote>
+<b>Effects:</b> Equivalent to
+<code>multi_index_container(list.begin(),list.end(),args_list,al)</code>.
+</blockquote>
+
+<code>multi_index_container(<br>
+ const multi_index_container<Value,IndexSpecifierList,Allocator>& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Constructs a copy of <code>x</code>, copying its
+elements as well as its internal objects (those specified
+in <code>ctor_args_list</code> and the allocator.)<br>
+<b>Postconditions:</b> <code>*this==x</code>. The order on every index
+of the <code>multi_index_container</code> is preserved as well.<br>
+<b>Complexity:</b> <code>O(x.size()*log(x.size()) + C(x.size()))</code>.
+</blockquote>
+
+<code>multi_index_container(<br>
+ multi_index_container<Value,IndexSpecifierList,Allocator>&& x);</code>
+
+<blockquote>
+<b>Effects:</b> Constructs a <code>multi_index_container</code> by moving the
+elements of <code>x</code> and copying its internal objects (those specified
+in <code>ctor_args_list</code> and the allocator.)<br>
+<b>Postconditions:</b> If <code>x==y</code> just
+before the movement, <code>*this==y</code>. The order on every index
+of the <code>multi_index_container</code> is preserved as well.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<code>~multi_index_container()</code>
+<blockquote>
+<b>Effects:</b> Destroys the <code>multi_index_container</code> and all the elements
+contained. The order in which the elements are destroyed is not specified.<br>
+<b>Complexity:</b> <code>O(n)</code>.
+</blockquote>
+
+<code>multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(<br>
+ const multi_index_container<Value,IndexSpecifierList,Allocator>& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Replaces the elements and internal objects of the <code>multi_index_container</code>
+with copies from <code>x</code>.<br>
+<b>Postconditions:</b> <code>*this==x</code>. The order on every index
+of the <code>multi_index_container</code> is preserved as well.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+<b>Complexity:</b> <code>O(n + x.size()*log(x.size()) +
+C(x.size()))</code>.<br>
+<b>Exception safety:</b> Strong, provided the copy and assignment operations
+of the types of <code>ctor_args_list</code> do not throw.
+</blockquote>
+
+<code>multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(<br>
+ multi_index_container<Value,IndexSpecifierList,Allocator>&& x);</code>
+
+<blockquote>
+<b>Effects:</b> Replaces the elements of <code>multi_index_container</code>
+with those of <code>x</code> and its internal objects with copies from the
+corresponding objects in <code>x</code>.<br>
+<b>Postconditions:</b> If <code>x==y</code> just
+before the movement, <code>*this==y</code>. The order on every index
+of the <code>multi_index_container</code> is preserved as well.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+<b>Complexity:</b> <code>O(n)</code>.<br>
+<b>Exception safety:</b> Strong, provided the copy and assignment operations
+of the types of <code>ctor_args_list</code> do not throw.
+</blockquote>
+
+<code>multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(<br>
+ std::initializer_list<Value> list);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Replaces the elements the <code>multi_index_container</code>
+with copies of the elements of <code>list</code>, inserted in the specified order.
+Insertion of each element may or may not succeed depending
+on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+<b>Complexity:</b> <code>O(n + I(m))</code>, where <code>m</code> is the
+number of elements of <code>list</code>.<br>
+<b>Exception safety:</b> Strong, provided the copy and assignment operations
+of the types of <code>ctor_args_list</code> do not throw.
+</blockquote>
+
+<code>allocator_type get_allocator()const noexcept;</code>
+
+<blockquote>
+Returns a copy of the <code>allocator_type</code> object used to construct
+the <code>multi_index_container</code>.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<h4><a name="index_retrieval">Index retrieval operations</a></h4>
+
+<code>template<int N> typename nth_index<N>::type& get()noexcept;</code>
+
+<blockquote>
+<b>Requires:</b> <code>0 <= N < I</code>.<br>
+<b>Effects:</b> Returns a reference to the
+<code>nth_index<N>::type</code> index held by <code>*this</code>.<br>
+<b>Complexity:</b> Constant.<br>
+</blockquote>
+
+<code>template<int N> const typename nth_index<N>::type& get()const noexcept;</code>
+
+<blockquote>
+<b>Requires:</b> <code>0 <= N < I</code>.<br>
+<b>Effects:</b> Returns a <code>const</code> reference to the
+<code>nth_index<N>::type</code> index held by <code>*this</code>.<br>
+<b>Complexity:</b> Constant.<br>
+</blockquote>
+
+<code>template<typename Tag> typename index<Tag>::type& get()noexcept;</code>
+
+<blockquote>
+<b>Requires:</b> <code>Tag</code> is such that <code>index<Tag>::type</code>
+is valid.<br>
+<b>Effects:</b> Returns a reference to the
+<code>index<Tag>::type</code> index held by
+<code>*this</code>.<br>
+<b>Complexity:</b> Constant.<br>
+</blockquote>
+
+<code>template<typename Tag> const typename index<Tag>::type& get()const noexcept;</code>
+
+<blockquote>
+<b>Requires:</b> <code>Tag</code> is such that <code>index<Tag>::type</code>
+is valid.<br>
+<b>Effects:</b> Returns a <code>const</code> reference to the
+<code>index<Tag>::type</code> index held by
+<code>*this</code>.<br>
+<b>Complexity:</b> Constant.<br>
+</blockquote>
+
+<h4><a name="projection">Projection operations</a></h4>
+
+<p>
+Given a <code>multi_index_container</code> with indices <code>i1</code>
+and <code>i2</code>, we say than an <code>i1</code>-iterator
+<code>it1</code> and an <code>i2</code>-iterator <code>it2</code>
+are <i>equivalent</i> if:
+<ul>
+ <li> <code>it1==i1.end()</code> AND <code>it2==i2.end()</code>,</li>
+ <li> OR <code>it1</code> and <code>it2</code> point to the
+ same element.</li>
+</ul>
+</p>
+
+<code>template<int N,typename IteratorType><br>
+typename nth_index<N>::type::iterator project(IteratorType it);</code>
+
+<blockquote>
+<b>Requires:</b> <code>0 <= N < I</code>. <code>IteratorType</code>
+belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
+iterator of some index of <code>*this</code> (i.e. does not refer to some
+other <code>multi_index_container</code>.)<br>
+<b>Effects:</b> Returns an <code>nth_index<N>::type::iterator</code>
+equivalent to <code>it</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.
+</blockquote>
+
+<code>template<int N,typename IteratorType><br>
+typename nth_index<N>::type::const_iterator project(IteratorType it)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>0 <= N < I</code>. <code>IteratorType</code>
+belongs to <code>const_iterator_type_list</code> or
+<code>iterator_type_list</code>. <code>it</code> is a
+valid (constant or non-constant) iterator of some index of <code>*this</code>
+(i.e. does not refer to some other <code>multi_index_container</code>.)<br>
+<b>Effects:</b> Returns an <code>nth_index<N>::type::const_iterator</code>
+equivalent to <code>it</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.
+</blockquote>
+
+<code>template<typename Tag,typename IteratorType><br>
+typename index<Tag>::type::iterator project(IteratorType it);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Tag</code> is such that
+<code>index<Tag>::type</code> is valid. <code>IteratorType</code>
+belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
+iterator of some index of <code>*this</code> (i.e. does not refer to some
+other <code>multi_index_container</code>.)<br>
+<b>Effects:</b> Returns an <code>index<Tag>::type::iterator</code>
+equivalent to <code>it</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.
+</blockquote>
+
+<code>template<typename Tag,typename IteratorType><br>
+typename index<Tag>::type::const_iterator project(IteratorType it)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>Tag</code> is such that
+<code>index<Tag>::type</code> is valid. <code>IteratorType</code>
+belongs to <code>const_iterator_type_list</code> or
+<code>iterator_type_list</code>. <code>it</code> is a valid
+(constant or non-constant) iterator of some index of <code>*this</code>
+(i.e. does not refer to some other <code>multi_index_container</code>.)<br>
+<b>Effects:</b> Returns an <code>index<Tag>::type::const_iterator</code>
+iterator equivalent to <code>it</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+<code>multi_index_container</code>s can be archived/retrieved by means of
+<a href="../../../serialization/index.html">Boost.Serialization</a>.
+Boost.MultiIndex does not expose a public serialization interface, as this
+is provided by Boost.Serialization itself. Both regular and XML
+archives are supported.
+</p>
+
+<p>
+Each of the indices comprising a given <code>multi_index_container</code> contributes
+its own preconditions as well as guarantees on the retrieved containers. In describing
+these, the following concepts are used. A type <code>T</code> is <i>serializable</i>
+(resp. XML-serializable) if any object of type <code>T</code> can be saved to an output
+archive (XML archive) and later retrieved from an input archive (XML archive) associated to
+the same storage. If <code>x'</code> of type <code>T</code> is loaded from the
+serialization information saved from another object <code>x</code>, we say that
+<code>x'</code> is a <i>restored copy</i> of <code>x</code>. Given a binary predicate
+<code>Pred</code> over (<code>T</code>, <code>T</code>), and objects <code>p</code>
+and <code>q</code> of type <code>Pred</code>, we say that <code>q</code>
+is <i>serialization-compatible</i> with <code>p</code> if
+<blockquote>
+<code>p(x,y) == q(x',y')</code>
+</blockquote>
+for every <code>x</code> and <code>y</code> of type <code>T</code> and <code>x'</code> and
+<code>y'</code> being restored copies of <code>x</code> and <code>y</code>,
+respectively.
+</p>
+
+Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
+output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
+each of the indices of <code>m</code> can impose another requirements.<br>
+<b>Exception safety:</b> Strong with respect to <code>m</code>. If an exception
+is thrown, <code>ar</code> may be left in an inconsistent state.
+</blockquote>
+
+Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
+input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
+each of the indices of <code>m'</code> can impose another requirements.<br>
+<b>Exception safety:</b> Basic. If an exception is thrown, <code>ar</code> may be
+left in an inconsistent state.
+</blockquote>
+
+<hr>
+
+<div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
+Index reference
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised April 13th 2018</p>
+
+<p>© Copyright 2003-2018 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/ord_indices.html b/doc/reference/ord_indices.html
new file mode 100644
index 0000000..9aa4536
--- /dev/null
+++ b/doc/reference/ord_indices.html
@@ -0,0 +1,1133 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Ordered indices reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="hash_indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Ordered indices reference</h1>
+
+<div class="prev_link"><a href="indices.html"><img src="../prev.gif" alt="index reference" border="0"><br>
+Index reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="rnk_indices.html"><img src="../next.gif" alt="ranked indices" border="0"><br>
+Ranked indices
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#ord_index_fwd_synopsis">Header
+ <code>"boost/multi_index/ordered_index_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/ordered_index.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#unique_non_unique">
+ Index specifiers <code>ordered_unique</code> and <code>ordered_non_unique</code>
+ </a></li>
+ <li><a href="#ord_indices">Ordered indices</a>
+ <ul>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#constructors">Constructors, copy and assignment</a></li>
+ <li><a href="#iterators">Iterators</a></li>
+ <li><a href="#modifiers">Modifiers</a></li>
+ <li><a href="#observers">Observers</a></li>
+ <li><a href="#set_operations">Set operations</a></li>
+ <li><a href="#range_operations">Range operations</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="ord_index_fwd_synopsis">Header
+<a href="../../../../boost/multi_index/ordered_index_fwd.hpp">
+<code>"boost/multi_index/ordered_index_fwd.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers ordered_unique and ordered_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult ordered_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ordered_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult ordered_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ordered_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index name is implementation defined</b><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>ordered_index_fwd.hpp</code> provides forward declarations for index specifiers
+<a href="#unique_non_unique"><code>ordered_unique</code> and <code>ordered_non_unique</code></a> and
+their associated <a href="#ord_indices">ordered index</a> classes.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index/ordered_index.hpp">
+<code>"boost/multi_index/ordered_index.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers ordered_unique and ordered_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult ordered_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ordered_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult ordered_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ordered_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="unique_non_unique">
+Index specifiers <code>ordered_unique</code> and <code>ordered_non_unique</code>
+</a></h3>
+
+<p>
+These <a href="indices.html#index_specification">index specifiers</a> allow
+for insertion of <a href="#ord_indices">ordered indices</a> without and with
+allowance of duplicate elements, respectively. The syntax of <code>ordered_unique</code>
+and <code>ordered_non_unique</code> coincide, thus we describe them in a grouped manner.
+<code>ordered_unique</code> and <code>ordered_non_unique</code> can be instantiated in
+two different forms, according to whether a tag list for the index is provided or not:
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>less</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>ordered_unique</span> <span class=special>|</span> <span class=identifier>ordered_non_unique</span><span class=special>)</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>less</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>ordered_unique</span> <span class=special>|</span> <span class=identifier>ordered_non_unique</span><span class=special>)</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>
+If provided, <code>TagList</code> must be an instantiation of the class template
+<a href="indices.html#tag"><code>tag</code></a>.
+The template arguments are used by the corresponding index implementation,
+refer to the <a href="#ord_indices">ordered indices</a> reference section for further
+explanations on their acceptable type values.
+</p>
+
+<h3><a name="ord_indices">Ordered indices</a></h3>
+
+<p>
+An ordered index provides a set-like interface to the underlying heap of
+elements contained in a <code>multi_index_container</code>. An ordered index is
+particularized according to a given
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+that retrieves keys from elements of <code>multi_index_container</code> and a comparison
+predicate.
+</p>
+
+<p>
+There are two variants of ordered indices: <i>unique</i>, which do
+not allow duplicate elements (with respect to its associated comparison
+predicate) and <i>non-unique</i>, which accept those duplicates.
+The interface of these two variants is the same, so they are documented
+together, with minor differences explicitly stated when they exist.
+</p>
+
+<p>
+Except where noted or if the corresponding interface does not exist,
+ordered indices (both unique and non-unique) satisfy the C++ requirements
+for associative containers at <b>[associative.reqmts]</b>
+(supporting unique and equivalent keys, respectively.)
+Accordingly, validity of iterators and references to elements is
+preserved. We only provide descriptions of those types and operations that
+do not exactly conform to or are not mandated by the standard requirements.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<b>implementation defined </b><span class=identifier>unbounded</span><span class=special>;</span> <span class=comment>// see range()</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined: dependent on types Value, Allocator,
+ TagList, KeyFromValue, Compare</b><span class=special>></span>
+<span class=keyword>class</span> <b>name is implementation defined</b>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span> <span class=identifier>key_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>KeyFromValue</span> <span class=identifier>key_from_value</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Compare</span> <span class=identifier>key_compare</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>value_compare</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>key_from_value</span><span class=special>,</span><span class=identifier>key_compare</span><span class=special>></span> <span class=identifier>ctor_args</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>TagList</span> <span class=identifier>tag_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>reference</span> <span class=identifier>reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_reference</span> <span class=identifier>const_reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>const_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>size_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>difference_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>pointer</span> <span class=identifier>pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_pointer</span> <span class=identifier>const_pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<iterator></b> <span class=identifier>reverse_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<const_iterator></b> <span class=identifier>const_reverse_iterator</span><span class=special>;</span>
+
+ <span class=comment>// construct/copy/destroy:</span>
+
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// iterators:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// capacity:</span>
+
+ <span class=keyword>bool</span> <span class=identifier>empty</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// modifiers:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>emplace_hint</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <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><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>);</span>
+ <span class=identifier>size_type</span> <span class=identifier>erase</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>clear</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// observers:</span>
+
+ <span class=identifier>key_from_value</span> <span class=identifier>key_extractor</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_compare</span> <span class=identifier>key_comp</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>value_compare</span> <span class=identifier>value_comp</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// set operations:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>lower_bound</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>lower_bound</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>upper_bound</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>upper_bound</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// range:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>LowerBounder</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>UpperBounder</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>range</span><span class=special>(</span>
+ <span class=identifier>LowerBounder</span> <span class=identifier>lower</span><span class=special>,</span><span class=identifier>UpperBounder</span> <span class=identifier>upper</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>==(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>size</span><span class=special>()==</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>size</span><span class=special>()&&</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>lexicographical_compare</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>!=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>==</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>y</span><span class=special><</span><span class=identifier>x</span><span class=special>;</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special><</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>></span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity_signature">Complexity signature</a></h4>
+
+<p>
+Here and in the descriptions of operations of ordered indices, we adopt the
+scheme outlined in the
+<a href="indices.html#complexity_signature">complexity signature
+section</a>. The complexity signature of ordered indices is:
+<ul>
+ <li>copying: <code>c(n)=n*log(n)</code>,</li>
+ <li>insertion: <code>i(n)=log(n)</code>,</li>
+ <li>hinted insertion: <code>h(n)=1</code> (constant) if the hint element
+ is immediately after the point of insertion, <code>h(n)=log(n)</code> otherwise,</li>
+ <li>deletion: <code>d(n)=1</code> (amortized constant),</li>
+ <li>replacement: <code>r(n)=1</code> (constant) if the element position does not
+ change, <code>r(n)=log(n)</code> otherwise,</li>
+ <li>modifying: <code>m(n)=1</code> (constant) if the element position does not
+ change, <code>m(n)=log(n)</code> otherwise.</li>
+</ul>
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>Ordered indices are instantiated internally to <code>multi_index_container</code> and
+specified by means of <a href="indices.html#indexed_by"><code>indexed_by</code></a>
+with <a href="#unique_non_unique"> index specifiers <code>ordered_unique</code>
+and <code>ordered_non_unique</code></a>. Instantiations are dependent on the
+following types:
+<ul>
+ <li><code>Value</code> from <code>multi_index_container</code>,</li>
+ <li><code>Allocator</code> from <code>multi_index_container</code>,</li>
+ <li><code>TagList</code> from the index specifier (if provided, otherwise <code>tag<></code> is assumed),</li>
+ <li><code>KeyFromValue</code> from the index specifier,</li>
+ <li><code>Compare</code> from the index specifier.</li>
+</ul>
+<code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>. The type <code>KeyFromValue</code>,
+which determines the mechanism for extracting a key from <code>Value</code>,
+must be a model of <a href="key_extraction.html#key_extractors">
+<code>Key Extractor</code></a> from <code>Value</code>. <code>Compare</code> is a
+<code>CopyConstructible</code> binary predicate inducing a strict weak order
+on elements of <code>KeyFromValue::result_type</code>.
+</p>
+
+<h4><a name="constructors">Constructors, copy and assignment</a></h4>
+
+<p>
+As explained in the <a href="indices.html#index_concepts">index
+concepts section</a>, indices do not have public constructors or destructors.
+Assignment, on the other hand, is provided.
+</p>
+
+<code><b>index class name</b>& operator=(const <b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>b</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> and <code>b</code> are the <code>multi_index_container</code>
+objects to which <code>*this</code> and <code>x</code> belong, respectively.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code><b>index class name</b>& operator=(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>list</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> is the <code>multi_index_container</code>
+object to which <code>*this</code> belongs.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<h4><a name="iterators">Iterators</a></h4>
+
+<code>iterator iterator_to(const value_type& x);<br>
+const_iterator iterator_to(const value_type& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>x</code> is a reference to an element of the container.<br>
+<b>Returns:</b> An iterator to <code>x</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<h4><a name="modifiers">Modifiers</a></h4>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace(Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+iterator emplace_hint(iterator position, Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<code>position</code> is used as a hint to improve the efficiency of the
+operation. If successful, insertion happens as close as possible to the
+location just prior to <code>position</code>.<br>
+<b>Returns:</b> On successful insertion, an iterator to the newly inserted
+element. Otherwise, an iterator to an element that caused the insertion to be
+banned. Note that more than one element can be causing insertion not to be
+allowed.<br>
+<b>Complexity:</b> <code>O(H(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> insert(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> insert(value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Effects:</b> Inserts <code>x</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>iterator insert(iterator position,const value_type& x);</code><br>
+<code>iterator insert(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts <code>x</code> into the <code>multi_index_container</code> to which
+the index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<code>position</code> is used as a hint to improve the efficiency of the
+operation. If successful, insertion happens as close as possible to the
+location just prior to <code>position</code>.<br>
+<b>Returns:</b> On successful insertion, an iterator to the newly inserted
+element. Otherwise, an iterator to an element that caused the insertion to be
+banned. Note that more than one element can be causing insertion not to be
+allowed.<br>
+<b>Complexity:</b> <code>O(H(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>template<typename InputIterator><br>
+void insert(InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>InputIterator</code> is an input iterator.
+<code>value_type</code> is <code>EmplaceConstructible</code> into
+<code>multi_index_container</code> from <code>*first</code>.
+<code>first</code> and <code>last</code> are not iterators into any
+index of the <code>multi_index_container</code> to which this index belongs.
+<code>last</code> is reachable from <code>first</code>.<br>
+<b>Effects:</b>
+For each element of [<code>first</code>, <code>last</code>), in this
+order, inserts it into the <code>multi_index_container</code>
+to which this index belongs if
+<ul>
+ <li>the index is non-unique OR no other element exists with
+ equivalent key,</li>
+ <li>AND insertion is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Complexity:</b> <code>O(m*H(n+m))</code>, where
+<code>m</code> is the number of elements in [<code>first</code>,
+<code>last</code>).<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>void insert(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>())</span><span class=special>;</span>
+</pre></blockquote>
+</blockquote>
+
+<code>iterator erase(iterator position);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid dereferenceable iterator
+of the index.<br>
+<b>Effects:</b> Deletes the element pointed to by <code>position</code>.<br>
+<b>Returns:</b> An iterator pointing to the element immediately following
+the one that was deleted, or <code>end()</code>
+if no such element exists.<br>
+<b>Complexity:</b> <code>O(D(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>size_type erase(const key_type& x);</code>
+
+<blockquote>
+<b>Effects:</b> Deletes the elements with key equivalent to <code>x</code>.<br>
+<b>Returns:</b> Number of elements deleted.<br>
+<b>Complexity:</b> <code>O(log(n) + m*D(n))</code>, where <code>m</code> is
+the number of elements deleted.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>iterator erase(iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> [<code>first</code>,<code>last</code>) is a valid
+range of the index.<br>
+<b>Effects:</b> Deletes the elements in [<code>first</code>,<code>last</code>).<br>
+<b>Returns:</b> <code>last</code>.<br>
+<b>Complexity:</b> <code>O(log(n) + m*D(n))</code>, where <code>m</code> is
+the number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="replace"><code>bool replace(iterator position,const value_type& x);</code></a><br>
+<code>bool replace(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Assigns the value <code>x</code> to the element pointed
+to by <code>position</code> into the <code>multi_index_container</code> to which
+the index belongs if, for the value <code>x</code>
+<ul>
+ <li>the index is non-unique OR no other element exists
+ (except possibly <code>*position</code>) with equivalent key,</li>
+ <li>AND replacing is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved
+in all cases. If the key of the new value is equivalent to that of the
+replaced value, the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the replacement took place,
+<code>false</code> otherwise.<br>
+<b>Complexity:</b> <code>O(R(n))</code>.<br>
+<b>Exception safety:</b> Strong. If an exception is thrown by some
+user-provided operation the <code>multi_index_container</code> to which the index
+belongs remains in its original state.
+</blockquote>
+
+<a name="modify">
+<code>template<typename Modifier> bool modify(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> is a unary function object
+accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and rearranges <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement is successful if
+<ul>
+ <li>the index is non-unique OR no other element exists
+ with equivalent key,</li>
+ <li>AND rearrangement is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+If the rearrangement fails, the element is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved if the
+operation succeeds. If the key of the modified value is equivalent to that of the
+original value, the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Basic. If an exception is thrown by some
+user-provided operation (including <code>mod</code>), then
+the element pointed to by <code>position</code> is erased.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> and <code>back</code> are unary function
+objects accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(e)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and tries to rearrange <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement is successful if
+<ul>
+ <li>the index is non-unique OR no other element exists
+ with equivalent key,</li>
+ <li>AND rearrangement is allowed by all other indices of the
+ <code>multi_index_container</code>.</li>
+</ul>
+If the rearrangement fails, <code>back(e)</code> is invoked: if the resulting value
+of <code>e</code> is consistent with its original position and constraints in all
+indices, the element is kept, otherwise it is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved except if
+the element is erased under the conditions described below.
+If the key of the modified value is equivalent to that of the
+original value, the position of the element does not change.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Strong, except if <code>mod</code> or <code>back</code> throw an
+exception or <code>back(e)</code> fails to properly restore the element or there is
+a throwing user-provided operation after invoking <code>back(e)</code>, in which cases
+the modified element is erased. If <code>back</code>
+throws inside the handling code executing after some other user-provided
+operation has thrown, it is the exception generated by <code>back</code> that
+is rethrown.
+</blockquote>
+
+<a name="modify_key">
+<code>template<typename Modifier> bool modify_key(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>key_from_value</code> is a read/write
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+from <code>value_type</code>. <code>mod</code> is a
+unary function object accepting arguments of type
+<code>key_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(k)</code>, where <code>k</code> is the key of the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>k</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Equivalent to <code>modify(position,mod')</code>,
+with <code>mod'</code> defined in such a way that
+<code>mod'(x)</code> is the same as <code>mod(key(x))</code>, where
+<code>key</code> is the internal <code>KeyFromValue</code> object of the index.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify_key(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>key_from_value</code> is a read/write
+<a href="key_extraction.html#key_extractors"><code>Key Extractor</code></a>
+from <code>value_type</code>. <code>mod</code> and <code>back</code>
+are unary function objects accepting arguments of type
+<code>key_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(k)</code>, where <code>k</code> is the key of the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>k</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(k)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Equivalent to <code>modify(position,mod',back')</code>,
+with <code>mod'</code> and <code>back</code> defined in such a way that
+<code>mod'(x)</code> is the same as <code>mod(key(x))</code> and
+<code>back'(x)</code> is the same as <code>back(key(x))</code>, where
+<code>key</code> is the internal <code>KeyFromValue</code> object of the index.
+</blockquote>
+
+<h4><a name="observers">Observers</a></h4>
+
+<p>Apart from standard <code>key_comp</code> and <code>value_comp</code>,
+ordered indices have a member function for retrieving the internal key extractor
+used.
+</p>
+
+<code>key_from_value key_extractor()const;</code>
+
+<blockquote>
+Returns a copy of the <code>key_from_value</code> object used to construct
+the index.<br>
+<b>Complexity:</b> Constant.
+</blockquote>
+
+<h4><a name="set_operations">Set operations</a></h4>
+
+<p>
+Ordered indices provide the full lookup functionality required by
+<b>[associative.reqmts]</b>, namely <code>find</code>,
+<code>count</code>, <code>lower_bound</code>, <code>upper_bound</code>
+and <code>equal_range</code>. Additionally, these member functions are
+templatized to allow for non-standard arguments, so extending
+the types of search operations allowed. The kind of arguments permissible
+when invoking the lookup member functions is defined by the following
+concept.
+</p>
+
+<p>
+Consider a binary predicate <code>Compare</code> inducing a strict
+weak order over values of type <code>Key</code>. A pair of types (<code>CompatibleKey</code>,
+<code>CompatibleCompare</code>) is said to be a <i>compatible extension</i>
+of <code>Compare</code> if
+<ol>
+ <li><code>CompatibleCompare</code> is a binary predicate over (<code>Key</code>,
+ <code>CompatibleKey</code>),</li>
+ <li><code>CompatibleCompare</code> is a binary predicate over (<code>CompatibleKey</code>,
+ <code>Key</code>),</li>
+ <li>if <code>c_comp(ck,k1)</code> then <code>!c_comp(k1,ck)</code>,</li>
+ <li>if <code>!c_comp(ck,k1)</code> and <code>!comp(k1,k2)</code> then
+ <code>!c_comp(ck,k2)</code>,</li>
+ <li>if <code>!c_comp(k1,ck)</code> and <code>!comp(k2,k1)</code> then
+ <code>!c_comp(k2,ck)</code>,</li>
+</ol>
+for every <code>c_comp</code> of type <code>CompatibleCompare</code>,
+<code>comp</code> of type <code>Compare</code>, <code>ck</code> of type
+<code>CompatibleKey</code> and <code>k1</code>, <code>k2</code> of type
+<code>Key</code>.
+</p>
+
+
+
+<p>Additionally, a type <code>CompatibleKey</code> is said to be a
+<i>compatible key</i> of <code>Compare</code> if (<code>CompatibleKey</code>,
+<code>Compare</code>) is a compatible extension of <code>Compare</code>.
+This implies that <code>Compare</code>, as well as being a strict
+weak ordering, accepts arguments of type <code>CompatibleKey</code>,
+which usually means it has several overloads of <code>operator()</code>.
+</p>
+
+<p>
+In the context of a compatible extension or a compatible key, the expressions
+"equivalent", "less than" and "greater than" take on their obvious
+interpretations.
+</p>
+
+<code>template<typename CompatibleKey> iterator find(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Returns a pointer to an element whose key is equivalent to
+<code>x</code>, or <code>end()</code> if such an element does not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+iterator find(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Returns a pointer to an element whose key is equivalent to
+<code>x</code>, or <code>end()</code> if such an element does not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey> size_type<br>
+count(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Returns the number of elements with key equivalent to <code>x</code>.<br>
+<b>Complexity:</b> <code>O(log(n) + count(x))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Returns the number of elements with key equivalent to <code>x</code>.<br>
+<b>Complexity:</b> <code>O(log(n) + count(x,comp))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+iterator lower_bound(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Returns an iterator pointing to the first element with
+key not less than <code>x</code>, or <code>end()</code> if such an element does
+not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+iterator lower_bound(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Returns an iterator pointing to the first element with
+key not less than <code>x</code>, or <code>end()</code> if such an element does
+not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+iterator upper_bound(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Returns an iterator pointing to the first element with
+key greater than <code>x</code>, or <code>end()</code> if such an element does
+not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+iterator upper_bound(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Returns an iterator pointing to the first element with
+key greater than <code>x</code>, or <code>end()</code> if such an element does
+not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+std::pair<iterator,iterator> equal_range(<br>
+ const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>make_pair(lower_bound(x),upper_bound(x))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+std::pair<iterator,iterator> equal_range(<br>
+ const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to
+<code>make_pair(lower_bound(x,comp),upper_bound(x,comp))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+
+<h4><a name="range_operations">Range operations</a></h4>
+
+<p>
+The member function <code>range</code> is not defined for sorted associative
+containers, but ordered indices provide it as a convenient utility. A range
+or interval is defined by two conditions for the lower and upper bounds, which
+are modeled after the following concepts.
+</p>
+
+<p>
+Consider a binary predicate <code>Compare</code> inducing a strict
+weak order over values of type <code>Key</code>. A type <code>LowerBounder</code> is said to be
+a <i>lower bounder</i> of <code>Compare</code> if
+<ol>
+ <li><code>LowerBounder</code> is a predicate over <code>Key</code>,</li>
+ <li>if <code>lower(k1)</code> and <code>!comp(k2,k1)</code> then
+ <code>lower(k2)</code>,</li>
+</ol>
+for every <code>lower</code> of type <code>LowerBounder</code>,
+<code>comp</code> of type <code>Compare</code>, and <code>k1</code>,
+<code>k2</code> of type <code>Key</code>. Similarly, an <i>upper bounder</i>
+is a type <code>UpperBounder</code> such that
+<ol>
+ <li><code>UpperBounder</code> is a predcate over <code>Key</code>,</li>
+ <li>if <code>upper(k1)</code> and <code>!comp(k1,k2)</code> then
+ <code>upper(k2)</code>,</li>
+</ol>
+for every <code>upper</code> of type <code>UpperBounder</code>,
+<code>comp</code> of type <code>Compare</code>, and <code>k1</code>,
+<code>k2</code> of type <code>Key</code>.
+</p>
+
+<code>template<typename LowerBounder,typename UpperBounder><br>
+std::pair<iterator,iterator> range(<br>
+ LowerBounder lower,UpperBounder upper)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>LowerBounder</code> and <code>UpperBounder</code> are
+a lower and upper bounder of <code>key_compare</code>, respectively.<br>
+<b>Effects:</b> Returns a pair of iterators pointing to the beginning and one
+past the end of the subsequence of elements satisfying <code>lower</code> and
+<code>upper</code> simultaneously. If no such elements exist, the iterators
+both point to the first element satisfying <code>lower</code>, or else
+are equal to <code>end()</code> if this latter element does not exist.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+<b>Variants:</b> In place of <code>lower</code> or <code>upper</code> (or both),
+the singular value <code>boost::multi_index::unbounded</code> can be
+provided. This acts as a predicate which all values of type <code>key_type</code>
+satisfy.<br>
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+Indices cannot be serialized on their own, but only as part of the
+<code>multi_index_container</code> into which they are embedded. In describing
+the additional preconditions and guarantees associated to ordered indices
+with respect to serialization of their embedding containers, we
+use the concepts defined in the <code>multi_index_container</code>
+<a href="multi_index_container.html#serialization">serialization section</a>.
+</p>
+
+Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
+output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.
+</blockquote>
+
+Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
+input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> Additionally to the general requirements, <code>value_comp()</code>
+must be serialization-compatible with <code>m.get<i>().value_comp()</code>,
+where <code>i</code> is the position of the ordered index in the container.<br>
+<b>Postconditions:</b> On successful loading, each of the elements of
+[<code>begin()</code>, <code>end()</code>) is a restored copy of the corresponding
+element in [<code>m.get<i>().begin()</code>, <code>m.get<i>().end()</code>).
+</blockquote>
+
+Operation: saving of an <code>iterator</code> or <code>const_iterator</code>
+<code>it</code> to an output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>it</code> is a valid iterator of the index. The associated
+<code>multi_index_container</code> has been previously saved.
+</blockquote>
+
+Operation: loading of an <code>iterator</code> or <code>const_iterator</code>
+<code>it'</code> from an input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Postconditions:</b> On successful loading, if <code>it</code> was dereferenceable
+then <code>*it'</code> is the restored copy of <code>*it</code>, otherwise
+<code>it'==end()</code>.<br>
+<b>Note:</b> It is allowed that <code>it</code> be a <code>const_iterator</code>
+and the restored <code>it'</code> an <code>iterator</code>, or viceversa.
+</blockquote>
+
+<hr>
+
+<div class="prev_link"><a href="indices.html"><img src="../prev.gif" alt="index reference" border="0"><br>
+Index reference
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="rnk_indices.html"><img src="../next.gif" alt="ranked indices" border="0"><br>
+Ranked indices
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised August 24th 2017</p>
+
+<p>© Copyright 2003-2017 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/rnd_indices.html b/doc/reference/rnd_indices.html
new file mode 100644
index 0000000..1f295db
--- /dev/null
+++ b/doc/reference/rnd_indices.html
@@ -0,0 +1,1130 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Random access indices reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="seq_indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="key_extraction.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Random access indices reference</h1>
+
+<div class="prev_link"><a href="seq_indices.html"><img src="../prev.gif" alt="sequenced indices" border="0"><br>
+Sequenced indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="key_extraction.html"><img src="../next.gif" alt="key extraction" border="0"><br>
+Key extraction
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#rnd_index_fwd_synopsis">Header
+ <code>"boost/multi_index/random_access_index_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/random_access_index.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#random_access"><code>random_access</code> index specifier</a></li>
+ <li><a href="#rnd_indices">Random access indices</a>
+ <ul>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#constructors">Constructors, copy and assignment</a></li>
+ <li><a href="#iterators">Iterators</a></li>
+ <li><a href="#capacity">Capacity operations</a></li>
+ <li><a href="#modifiers">Modifiers</a></li>
+ <li><a href="#list_operations">List operations</a></li>
+ <li><a href="#rearrange_operations">Rearrange operations</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="rnd_index_fwd_synopsis">Header
+<a href="../../../../boost/multi_index/random_access_index_fwd.hpp">
+<code>"boost/multi_index/random_access_index_fwd.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// random_access index specifier</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>random_access</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>random_access_index_fwd.hpp</code> provides forward declarations for the
+<a href="#random_access"><code>random_access</code></a> index specifier and
+its associated <a href="#rnd_indices">random access index</a> class.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index/random_access_index.hpp">
+<code>"boost/multi_index/random_access_index.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// random_access index specifier</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>random_access</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="random_access">
+<code>random_access</code> index specifier
+</a></h3>
+
+<p>
+This index specifier allows for insertion of a <a href="#rnd_indices">random
+access index</a>.</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>random_access</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>If provided, <code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>.
+</p>
+
+<h3><a name="rnd_indices">Random access indices</a></h3>
+
+<p>
+Random access indices are free-order sequences with constant time
+positional access and random access iterators. Elements in a
+random access index are by default sorted according to their order of
+insertion: this means that new elements inserted through a different index
+of the <code>multi_index_container</code> are appended to the end of the
+random access index; additionally, facilities are provided
+for further rearrangement of the elements. The public interface of
+random access indices includes that of
+<a href="seq_indices.html">sequenced indices</a>, with differences in
+the complexity of the operations, plus extra operations for
+positional access (<code>operator[]</code> and <code>at()</code>) and
+for capacity handling. Validity of iterators and references to elements
+is preserved in all operations, regardless of the capacity status.
+</p>
+
+<p>
+Except where noted or if the corresponding interface does not exist, random access
+indices verify the same container requirements as <code>std::vector</code>
+plus the requirements for <code>std::list</code> specific list operations at
+<b>[list.ops]</b>. Some of the most important differences with respect to
+<code>std::vector</code> are:
+<ul>
+ <li>Random access indices do not provide memory contiguity, and hence do not
+ have <code>data</code> member functions.
+ </li>
+
+ <li>The complexity of some operations, notably insertion and deletion, differ
+ from those of <code>std::vector</code>.
+ </li>
+ <li>Unlike as in <code>std::vector</code>, insertions into a random access index
+ may fail due to clashings with other indices. This alters the semantics
+ of the operations provided with respect to their analogues in
+ <code>std::vector</code>.
+ </li>
+ <li>Elements in a randon access index are not mutable, and can only be changed
+ by means of <a href="#replace"><code>replace</code></a> and
+ <a href="#modify"><code>modify</code></a> member functions.
+ </li>
+ <li><code>push_front</code> and <code>pop_front</code> are provided for
+ compatibility with sequenced indices, even though they take linear time to execute.
+ </li></ul>
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined: dependent on types Value, Allocator, TagList</b><span class=special>></span>
+<span class=keyword>class</span> <b>name is implementation defined</b>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuples</span><span class=special>::</span><span class=identifier>null_type</span> <span class=identifier>ctor_args</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>TagList</span> <span class=identifier>tag_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>reference</span> <span class=identifier>reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>const_reference</span> <span class=identifier>const_reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>const_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>size_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>ptrdiff_t</span> <span class=identifier>difference_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>pointer</span> <span class=identifier>pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>const_pointer</span> <span class=identifier>const_pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<iterator></b> <span class=identifier>reverse_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<const_iterator></b> <span class=identifier>const_reverse_iterator</span><span class=special>;</span>
+
+ <span class=comment>// construct/copy/destroy:</span>
+
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>class</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>)</span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>value</span><span class=special>);</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// iterators:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// capacity:</span>
+
+ <span class=keyword>bool</span> <span class=identifier>empty</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>capacity</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=keyword>void</span> <span class=identifier>reserve</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>m</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>shrink_to_fit</span><span class=special>();</span>
+
+ <span class=keyword>void</span> <span class=identifier>resize</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>resize</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=comment>// access:</span>
+
+ <span class=identifier>const_reference</span> <span class=keyword>operator</span><span class=special>[](</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_reference</span> <span class=identifier>at</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_reference</span> <span class=identifier>front</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_reference</span> <span class=identifier>back</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// modifiers:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace_front</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_front</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_front</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>pop_front</span><span class=special>();</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace_back</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_back</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_back</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>pop_back</span><span class=special>();</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>size_type</span> <span class=identifier>m</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>clear</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// list operations:</span>
+
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>i</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span>
+ <span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>remove</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>value</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Predicate</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>remove_if</span><span class=special>(</span><span class=identifier>Predicate</span> <span class=identifier>pred</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>unique</span><span class=special>();</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>class</span> <span class=identifier>BinaryPredicate</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>unique</span><span class=special>(</span><span class=identifier>BinaryPredicate</span> <span class=identifier>binary_pred</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>merge</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>merge</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>Compare</span> <span class=identifier>comp</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>sort</span><span class=special>();</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>sort</span><span class=special>(</span><span class=identifier>Compare</span> <span class=identifier>comp</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>reverse</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// rearrange operations:</span>
+
+ <span class=keyword>void</span> <span class=identifier>relocate</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>i</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>relocate</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>rearrange</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>==(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>size</span><span class=special>()==</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>size</span><span class=special>()&&</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>lexicographical_compare</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>!=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>==</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span>
+ <span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>y</span><span class=special><</span><span class=identifier>x</span><span class=special>;</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special><</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>></span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity_signature">Complexity signature</a></h4>
+
+<p>
+Here and in the descriptions of operations of random access indices, we
+adopt the scheme outlined in the
+<a href="indices.html#complexity_signature">complexity signature
+section</a>. The complexity signature of random access indices is:
+<ul>
+ <li>copying: <code>c(n)=n*log(n)</code>,</li>
+ <li>insertion: <code>i(n)=1</code> (amortized constant),</li>
+ <li>hinted insertion: <code>h(n)=1</code> (amortized constant),</li>
+ <li>deletion: <code>d(n)=m</code>, where <code>m</code> is the distance
+ from the deleted element to the end of the sequence,</li>
+ <li>replacement: <code>r(n)=1</code> (constant),</li>
+ <li>modifying: <code>m(n)=1</code> (constant).</li>
+</ul>
+The following expressions are also used as a convenience for writing down some
+of the complexity formulas:
+</p>
+
+<blockquote>
+<code>shl(a,b)</code> = <code>a+b</code> if a is nonzero, <code>0</code> otherwise.<br>
+<code>rel(a,b,c)</code> = if <code>a<b</code>, <code>c-a</code>, else <code>a-b</code>,
+</blockquote>
+
+<p>
+(<code>shl</code> and <code>rel</code> stand for <i>shift left</i> and
+<i>relocate</i>, respectively.)
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>Random access indices are instantiated internally to <code>multi_index_container</code>
+and specified by means of <a href="indices.html#indexed_by">
+<code>indexed_by</code></a> with the <a href="#random_access"><code>random_access</code></a>
+index specifier. Instantiations are dependent on the following types:
+<ul>
+ <li><code>Value</code> from <code>multi_index_container</code>,</li>
+ <li><code>Allocator</code> from <code>multi_index_container</code>,</li>
+ <li><code>TagList</code> from the index specifier (if provided, otherwise <code>tag<></code> is assumed).</li>
+</ul>
+<code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>.
+</p>
+
+<h4><a name="constructors">Constructors, copy and assignment</a></h4>
+
+<p>
+As explained in the <a href="indices.html#index_concepts">index
+concepts section</a>, indices do not have public constructors or destructors.
+Assignment, on the other hand, is provided.
+</p>
+
+<code><b>index class name</b>& operator=(const <b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>b</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> and <code>b</code> are the <code>multi_index_container</code>
+objects to which <code>*this</code> and <code>x</code> belong, respectively.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code><b>index class name</b>& operator=(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>list</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> is the <code>multi_index_container</code>
+object to which <code>*this</code> belongs.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code>template <class InputIterator><br>
+void assign(InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>clear</span><span class=special>();</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>first</span><span class=special>,</span><span class=identifier>last</span><span class=special>);</span>
+</pre></blockquote>
+</blockquote>
+
+<code>void assign(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>assign</span><span class=special>(</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+</pre></blockquote>
+</blockquote>
+
+<code>void assign(size_type n,const value_type& value);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>clear</span><span class=special>();</span>
+<span class=keyword>for</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>i</span><span class=special>=</span><span class=number>0</span><span class=special>;</span><span class=identifier>i</span><span class=special><</span><span class=identifier>n</span><span class=special>;++</span><span class=identifier>n</span><span class=special>)</span><span class=identifier>push_back</span><span class=special>(</span><span class=identifier>v</span><span class=special>);</span>
+</pre></blockquote>
+</blockquote>
+
+<h4><a name="iterators">Iterators</a></h4>
+
+<code>iterator iterator_to(const value_type& x);<br>
+const_iterator iterator_to(const value_type& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>x</code> is a reference to an element of the container.<br>
+<b>Returns:</b> An iterator to <code>x</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<h4><a name="capacity">Capacity operations</a></h4>
+
+<a name="capacity_memfun"><code>size_type capacity()const noexcept;</code></a>
+
+<blockquote>
+<b>Returns:</b> The total number of elements <code>c</code> such that, when
+<code>size()<c</code>, back insertions happen in constant time (the
+general case as described by
+<a href="#complexity_signature"><code>i(n)</code></a> is <i>amortized</i>
+constant time.)<br>
+<b>Note:</b> Validity of iterators and references to elements
+is preserved in all insertions, regardless of the capacity status.
+</blockquote>
+
+<a name="reserve"><code>void reserve(size_type m);</code></a>
+
+<blockquote>
+<b>Effects:</b> If the previous value of <code>capacity()</code>
+was greater than or equal to <code>m</code>, nothing is done;
+otherwise, the internal capacity is changed so that
+<code>capacity()>=m</code>.<br>
+<b>Complexity:</b> If the capacity is not changed, constant;
+otherwise <code>O(n)</code>.<br>
+<b>Exception safety:</b> If the capacity is not changed, <code>nothrow</code>;
+otherwise, strong.<br>
+</blockquote>
+
+<code>void shrink_to_fit();</code>
+
+<blockquote>
+<b>Effects:</b> Reduces <code>capacity()</code> to <code>size()</code>.<br>
+<b>Complexity:</b> If the capacity is not changed, constant;
+otherwise <code>O(n)</code>.<br>
+<b>Exception safety:</b> If the capacity is not changed, <code>nothrow</code>;
+otherwise, strong.<br>
+</blockquote>
+
+<code>void resize(size_type n);<br>
+void resize(size_type n,const value_type& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>DefaultInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Effects:</b> If <code>size()<n</code>, tries to append <code>n-size()</code> default-inserted
+elements (first version) or copies of <code>x</code> (second version) at the end of
+the index. If <code>n<size()</code>, erases the last <code>size()-n</code> elements.<br>
+<b>Note:</b> If an expansion is requested, the size of the index is not guaranteed
+to be <code>n</code> after this operation (other indices may ban insertions.)
+</blockquote>
+
+<h4><a name="modifiers">Modifiers</a></h4>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace_front(Args&&... args);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>emplace</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>forward</span><span class=special><</span><span class=identifier>Args</span><span class=special>>(</span><span class=identifier>args</span><span class=special>)...);</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> push_front(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> push_front(value_type&& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>);</span> <span class=comment>// lvalue ref version</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>move</span><span class=special>(</span><span class=identifier>x</span><span class=special>));</span> <span class=comment>// rvalue ref version</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace_back(Args&&... args);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>emplace</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>forward</span><span class=special><</span><span class=identifier>Args</span><span class=special>>(</span><span class=identifier>args</span><span class=special>)...);</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> push_back(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> push_back(value_type&& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>x</span><span class=special>);</span> <span class=comment>// lvalue ref version</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>move</span><span class=special>(</span><span class=identifier>x</span><span class=special>));</span> <span class=comment>// rvalue ref version</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+ std::pair<iterator,bool> emplace(iterator position,Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> before <code>position</code> if insertion
+is allowed by all other indices of the <code>multi_index_container</code>.<br>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> insert(iterator position,const value_type& x);</code><br>
+<code>std::pair<iterator,bool> insert(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts <code>x</code> before <code>position</code> if insertion
+is allowed by all other indices of the <code>multi_index_container</code>.<br>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.
+</blockquote>
+
+<code>void insert(iterator position,size_type m,const value_type& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=keyword>for</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>i</span><span class=special>=</span><span class=number>0</span><span class=special>;</span><span class=identifier>i</span><span class=special><</span><span class=identifier>m</span><span class=special>;++</span><span class=identifier>i</span><span class=special>)</span><span class=identifier>insert</span><span class=special>(</span><span class=identifier>position</span><span class=special>,</span><span class=identifier>x</span><span class=special>);</span>
+</pre></blockquote>
+<b>Complexity:</b> <code>O(shl(end()-position,m) + m*I(n+m))</code>.
+</blockquote>
+
+<code>template<typename InputIterator><br>
+void insert(iterator position,InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>InputIterator</code> is an input iterator.
+<code>value_type</code> is
+<code>EmplaceConstructible</code> into
+<code>multi_index_container</code> from <code>*first</code>.
+<code>first</code> and <code>last</code> are not iterators into any
+index of the <code>multi_index_container</code> to which this index belongs.
+<code>last</code> is reachable from <code>first</code>.<br>
+<b>Effects:</b>
+For each element of [<code>first</code>, <code>last</code>), in this
+order, inserts it before <code>position</code> if insertion is allowed by all
+other indices of the <code>multi_index_container</code>.<br>
+<b>Complexity:</b> <code>O(shl(end()-position,m) + m*I(n+m))</code>,
+where <code>m</code> is the number of elements in
+[<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void insert(iterator position,std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>position</span><span class=special>,</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+</pre></blockquote>
+</blockquote>
+
+<code>iterator erase(iterator position);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid dereferenceable iterator
+of the index.<br>
+<b>Effects:</b> Deletes the element pointed to by <code>position</code>.<br>
+<b>Returns:</b> An iterator pointing to the element immediately following
+the one that was deleted, or <code>end()</code>
+if no such element exists.<br>
+<b>Complexity:</b> <code>O(D(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>iterator erase(iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> [<code>first</code>,<code>last</code>) is a valid
+range of the index.<br>
+<b>Effects:</b> Deletes the elements in [<code>first</code>,<code>last</code>).<br>
+<b>Returns:</b> <code>last</code>.<br>
+<b>Complexity:</b> <code>O(m*D(n))</code>, where <code>m</code> is
+the number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="replace"><code>bool replace(iterator position,const value_type& x);</code></a><br>
+<code>bool replace(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Assigns the value <code>x</code> to the element pointed
+to by <code>position</code> into the <code>multi_index_container</code> to which
+the index belongs if replacing is allowed by all other indices of the
+<code>multi_index_container</code>.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved
+in all cases.<br>
+<b>Returns:</b> <code>true</code> if the replacement took place,
+<code>false</code> otherwise.<br>
+<b>Complexity:</b> <code>O(R(n))</code>.<br>
+<b>Exception safety:</b> Strong. If an exception is thrown by some
+user-provided operation the <code>multi_index_container</code> to which the index
+belongs remains in its original state.
+</blockquote>
+
+<a name="modify">
+<code>template<typename Modifier> bool modify(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> is a unary function object
+accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and rearranges <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement on sequenced
+indices does not change the position of the element with respect to the index;
+rearrangement on other indices may or might not succeed. If the rearrangement
+fails, the element is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved if the
+operation succeeds.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Basic. If an exception is thrown by some
+user-provided operation (including <code>mod</code>), then
+the element pointed to by <code>position</code> is erased.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> and <code>back</code> are unary function
+objects accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(e)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and tries to rearrange <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement on sequenced
+indices does not change the position of the element with respect to the index;
+rearrangement on other indices may or might not succeed.
+If the rearrangement fails, <code>back(e)</code> is invoked: if the resulting value
+of <code>e</code> is consistent with its original position and constraints in all
+indices, the element is kept, otherwise it is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved except if
+the element is erased under the conditions described below.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Strong, except if <code>mod</code> or <code>back</code> throw an
+exception or <code>back(e)</code> fails to properly restore the element or there is
+a throwing user-provided operation after invoking <code>back(e)</code>, in which cases
+the modified element is erased. If <code>back</code>
+throws inside the handling code executing after some other user-provided
+operation has thrown, it is the exception generated by <code>back</code> that
+is rethrown.
+</blockquote>
+
+<h4><a name="list_operations">List operations</a></h4>
+
+<p>
+Random access indices replicate the interface of sequenced indices, which
+in turn includes the list operations provided by <code>std::list</code>.
+The syntax and behavior of these operations exactly matches those
+of sequenced indices, but the associated complexity bounds differ in general.
+</p>
+
+<code>void splice(iterator position,<b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>&x!=this</code>.<br>
+<b>Effects:</b> Inserts the contents of <code>x</code> before <code>position</code>,
+in the same order as they were in <code>x</code>. Those elements successfully
+inserted are erased from <code>x</code>.<br>
+<b>Complexity:</b> <code>O(shl(end()-position,x.size()) + x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>void splice(iterator position,<b>index class name</b>& x,iterator i);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>i</code> is a valid dereferenceable iterator <code>x</code>.<br>
+<b>Effects:</b> Inserts the element pointed to by <code>i</code> before
+<code>position</code>: if insertion is successful, the element is erased from
+<code>x</code>. In the special case <code>&x==this</code>, no copy or
+deletion is performed, and the operation is always successful. If
+<code>position==i</code>, no operation is performed.<br>
+<b>Postconditions:</b> If <code>&x==this</code>, no iterator or reference
+is invalidated.<br>
+<b>Complexity:</b> If <code>&x==this</code>, <code>O(rel(position,i,i+1))</code>;
+otherwise <code>O(shl(end()-position,1) + I(n) + D(n))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, strong.<br>
+</blockquote>
+
+<code>void splice(iterator position,<b>index class name&</b> x,iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>first</code> and <code>last</code> are valid iterators of <code>x</code>.
+<code>last</code> is reachable from <code>first</code>. <code>position</code>
+is not in the range [<code>first</code>,<code>last</code>).<br>
+<b>Effects:</b> For each element in the range [<code>first</code>,<code>last</code>),
+insertion is tried before <code>position</code>; if the operation is successful,
+the element is erased from <code>x</code>. In the special case
+<code>&x==this</code>, no copy or deletion is performed, and insertions are
+always successful.<br>
+<b>Postconditions:</b> If <code>&x==this</code>, no iterator or reference
+is invalidated.<br>
+<b>Complexity:</b> If <code>&x==this</code>,
+<code>O(rel(position,first,last))</code>; otherwise
+<code>O(shl(end()-position,m) + m*I(n+m) + m*D(x.size()))</code>
+where <code>m</code> is the number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>void remove(const value_type& value);</code>
+
+<blockquote>
+<b>Effects:</b> Erases all elements of the index which compare equal to
+<code>value</code>.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>template<typename Predicate> void remove_if(Predicate pred);</code>
+
+<blockquote>
+<b>Effects:</b> Erases all elements <code>x</code> of the index for which
+<code>pred(x)</code> holds.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void unique();</code>
+
+<blockquote>
+<b>Effects:</b> Eliminates all but the first element from every consecutive
+group of equal elements referred to by the iterator <code>i</code> in the range
+[<code>first+1</code>,<code>last</code>) for which <code>*i==*(i-1)</code>.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);</code>
+
+<blockquote>
+<b>Effects:</b> Eliminates all but the first element from every consecutive
+group of elements referred to by the iterator <code>i</code> in the range
+[<code>first+1</code>,<code>last</code>) for which
+<code>binary_pred(*i,*(i-1))</code> holds.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void merge(index class name& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>std::less<value_type></code> induces a
+strict weak ordering over <code>value_type</code>.
+Both the index and <code>x</code> are sorted according to
+<code>std::less<value_type></code>.<br>
+<b>Effects:</b> Attempts to insert every element of <code>x</code> into the
+corresponding position of the index (according to the order). Elements
+successfully inserted are erased from <code>x</code>. The resulting sequence
+is stable, i.e. equivalent elements of either container preserve their
+relative position. In the special case <code>&x==this</code>, no operation
+is performed.<br>
+<b>Postconditions:</b> Elements in the index and remaining elements in
+<code>x</code> are sorted.
+Validity of iterators to the index and of non-erased elements of <code>x</code>
+references is preserved.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(n + x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>template <typename Compare> void merge(index class name& x,Compare comp);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Compare</code> induces a
+strict weak ordering over <code>value_type</code>.
+Both the index and <code>x</code> are sorted according to <code>comp</code>.<br>
+<b>Effects:</b> Attempts to insert every element of <code>x</code> into the
+corresponding position of the index (according to <code>comp</code>).
+Elements successfully inserted are erased from <code>x</code>. The resulting
+sequence is stable, i.e. equivalent elements of either container preserve
+their relative position. In the special case <code>&x==this</code>, no
+operation is performed.<br>
+<b>Postconditions:</b> Elements in the index and remaining elements in
+<code>x</code> are sorted according to <code>comp</code>.
+Validity of iterators to the index and of non-erased elements of <code>x</code>
+references is preserved.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(n + x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>void sort();</code>
+
+<blockquote>
+<b>Requires:</b> <code>std::less<value_type></code> induces a
+strict weark ordering over <code>value_type</code>.<br>
+<b>Effects:</b> Sorts the index according to
+<code>std::less<value_type></code>. The sorting is stable, i.e.
+equivalent elements preserve their relative position.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n*log(n))</code>.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>template <typename Compare> void sort(Compare comp);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Compare</code> induces a
+strict weak ordering over <code>value_type</code>.<br>
+<b>Effects:</b> Sorts the index according to <code>comp</code>. The sorting
+is stable, i.e. equivalent elements preserve their relative position.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n*log(n))</code>.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void reverse()noexcept;</code>
+
+<blockquote>
+<b>Effects:</b> Reverses the order of the elements in the index.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n)</code>.<br>
+</blockquote>
+
+<h4><a name="rearrange_operations">Rearrange operations</a></h4>
+
+<p>
+These operations, without counterpart in STL sequence containers
+(although <code>std::list::splice</code> provides partially overlapping
+functionality), perform individual and global repositioning of elements
+inside the index.
+</p>
+
+<code>void relocate(iterator position,iterator i);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>i</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Inserts the element pointed to by <code>i</code> before
+<code>position</code>. If <code>position==i</code>, no operation is
+performed.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> <code>O(rel(position,i,i+1))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>void relocate(iterator position,iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>first</code> and <code>last</code> are valid iterators of the index.
+<code>last</code> is reachable from <code>first</code>. <code>position</code>
+is not in the range [<code>first</code>,<code>last</code>).<br>
+<b>Effects:</b> The range of elements [<code>first</code>,<code>last</code>)
+is repositioned just before <code>position</code>.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> <code>O(rel(position,first,last))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="rearrange"><code>template<typename InputIterator> void rearrange(InputIterator first);</code></a>
+
+<blockquote>
+<b>Requires:</b> The range [<code>first</code>,
+<code>std::advance(first,n)</code>),
+where <code>n</code> is the size of the index, is a
+<a href="indices.html#views">free view</a> of the index.<br>
+<b>Effects:</b> The elements are rearranged so as to match the
+order of the previously described view.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> <code>O(n)</code>.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+Indices cannot be serialized on their own, but only as part of the
+<code>multi_index_container</code> into which they are embedded. In describing
+the additional preconditions and guarantees associated to random access indices
+with respect to serialization of their embedding containers, we
+use the concepts defined in the <code>multi_index_container</code>
+<a href="multi_index_container.html#serialization">serialization section</a>.
+</p>
+
+Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
+output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.
+</blockquote>
+
+Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
+input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.<br>
+<b>Postconditions:</b> On successful loading, each of the elements of
+[<code>begin()</code>, <code>end()</code>) is a restored copy of the corresponding
+element in [<code>m.get<i>().begin()</code>, <code>m.get<i>().end()</code>),
+where <code>i</code> is the position of the random access index in the container.
+</blockquote>
+
+Operation: saving of an <code>iterator</code> or <code>const_iterator</code>
+<code>it</code> to an output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>it</code> is a valid iterator of the index. The associated
+<code>multi_index_container</code> has been previously saved.
+</blockquote>
+
+Operation: loading of an <code>iterator</code> or <code>const_iterator</code>
+<code>it'</code> from an input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Postconditions:</b> On successful loading, if <code>it</code> was dereferenceable
+then <code>*it'</code> is the restored copy of <code>*it</code>, otherwise
+<code>it'==end()</code>.<br>
+<b>Note:</b> It is allowed that <code>it</code> be a <code>const_iterator</code>
+and the restored <code>it'</code> an <code>iterator</code>, or viceversa.
+</blockquote>
+
+<hr>
+
+<div class="prev_link"><a href="seq_indices.html"><img src="../prev.gif" alt="sequenced indices" border="0"><br>
+Sequenced indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="key_extraction.html"><img src="../next.gif" alt="key extraction" border="0"><br>
+Key extraction
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised August 24th 2017</p>
+
+<p>© Copyright 2003-2017 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/rnk_indices.html b/doc/reference/rnk_indices.html
new file mode 100644
index 0000000..9a5a960
--- /dev/null
+++ b/doc/reference/rnk_indices.html
@@ -0,0 +1,645 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Ranked indices reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="hash_indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Ranked indices reference</h1>
+
+<div class="prev_link"><a href="ord_indices.html"><img src="../prev.gif" alt="ordered_indices" border="0"><br>
+Ordered indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="hash_indices.html"><img src="../next.gif" alt="hashed indices" border="0"><br>
+Hashed indices
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#rnk_index_fwd_synopsis">Header
+ <code>"boost/multi_index/ranked_index_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/ranked_index.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#unique_non_unique">
+ Index specifiers <code>ranked_unique</code> and <code>ranked_non_unique</code>
+ </a></li>
+ <li><a href="#rnk_indices">Ranked indices</a>
+ <ul>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#rank_operations">Rank operations</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="rnk_index_fwd_synopsis">Header
+<a href="../../../../boost/multi_index/ranked_index_fwd.hpp">
+<code>"boost/multi_index/ranked_index_fwd.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers ranked_unique and ranked_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult ranked_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ranked_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult ranked_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ranked_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index name is implementation defined</b><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>ranked_index_fwd.hpp</code> provides forward declarations for index specifiers
+<a href="#unique_non_unique"><code>ranked_unique</code> and <code>ranked_non_unique</code></a> and
+their associated <a href="#rnk_indices">ranked index</a> classes.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index/ranked_index.hpp">
+<code>"boost/multi_index/ranked_index.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// index specifiers ranked_unique and ranked_non_unique</span>
+
+<span class=keyword>template</span><span class=special><</span><b>consult ranked_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ranked_unique</span><span class=special>;</span>
+<span class=keyword>template</span><span class=special><</span><b>consult ranked_non_unique reference for arguments</b><span class=special>></span>
+<span class=keyword>struct</span> <span class=identifier>ranked_non_unique</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="unique_non_unique">
+Index specifiers <code>ranked_unique</code> and <code>ranked_non_unique</code>
+</a></h3>
+
+<p>
+These <a href="indices.html#index_specification">index specifiers</a> allow
+for insertion of <a href="#rnk_indices">ranked indices</a> without and with
+allowance of duplicate elements, respectively. The syntax of <code>ranked_unique</code>
+and <code>ranked_non_unique</code> coincide, thus we describe them in a grouped manner.
+<code>ranked_unique</code> and <code>ranked_non_unique</code> can be instantiated in
+two different forms, according to whether a tag list for the index is provided or not:
+</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>less</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>ranked_unique</span> <span class=special>|</span> <span class=identifier>ranked_non_unique</span><span class=special>)</span><span class=special>;</span>
+
+<span class=keyword>template</span><span class=special><</span>
+ <span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>,</span>
+ <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>less</span><span class=special><</span><span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span><span class=special>></span>
+<span class=special>></span>
+<span class=keyword>struct</span> <span class=special>(</span><span class=identifier>ranked_unique</span> <span class=special>|</span> <span class=identifier>ranked_non_unique</span><span class=special>)</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>
+If provided, <code>TagList</code> must be an instantiation of the class template
+<a href="indices.html#tag"><code>tag</code></a>.
+The template arguments are used by the corresponding index implementation,
+refer to the <a href="#rnk_indices">ranked indices</a> reference section for further
+explanations on their acceptable type values.
+</p>
+
+<h3><a name="rnk_indices">Ranked indices</a></h3>
+
+<p>
+Ranked indices are a variation of <a href="ord_indices.html">ordered indices</a>
+providing additional capabilities for calculation of and access by rank; the <i>rank</i> of an element is the
+distance to it from the beginning of the index. Besides this extension, ranked indices replicate the
+public interface of ordered indices with the difference, complexity-wise, that <a href="#complexity_signature">deletion</a>
+is done in logarithmic rather than constant time. Also, execution times and memory consumption are
+expected to be poorer due to the internal bookkeeping needed to maintain rank-related information.
+As with ordered indices, ranked indices can be unique (no duplicate elements are allowed)
+or non-unique: either version is associated to a different index specifier, but
+the interface of both index types is the same.
+</p>
+
+<p>
+In what follows, we only describe the extra operations provided by ranked indices: for the
+rest refer to the <a href="ord_indices.html#ord_indices">documentation</a> for ordered
+indices, bearing in mind the occasional differences in complexity.
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<b>implementation defined </b><span class=identifier>unbounded</span><span class=special>;</span> <span class=comment>// see range_rank()</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined: dependent on types Value, Allocator,
+ TagList, KeyFromValue, Compare</b><span class=special>></span>
+<span class=keyword>class</span> <b>name is implementation defined</b>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>KeyFromValue</span><span class=special>::</span><span class=identifier>result_type</span> <span class=identifier>key_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>KeyFromValue</span> <span class=identifier>key_from_value</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Compare</span> <span class=identifier>key_compare</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>value_compare</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special><</span><span class=identifier>key_from_value</span><span class=special>,</span><span class=identifier>key_compare</span><span class=special>></span> <span class=identifier>ctor_args</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>TagList</span> <span class=identifier>tag_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>reference</span> <span class=identifier>reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_reference</span> <span class=identifier>const_reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>const_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>size_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined </b><span class=identifier>difference_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>pointer</span> <span class=identifier>pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>::</span><span class=identifier>const_pointer</span> <span class=identifier>const_pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<iterator></b> <span class=identifier>reverse_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<const_iterator></b> <span class=identifier>const_reverse_iterator</span><span class=special>;</span>
+
+ <span class=comment>// construct/copy/destroy:</span>
+
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// iterators:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// capacity:</span>
+
+ <span class=keyword>bool</span> <span class=identifier>empty</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// modifiers:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>emplace_hint</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <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><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>);</span>
+ <span class=identifier>size_type</span> <span class=identifier>erase</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify_key</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>clear</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// observers:</span>
+
+ <span class=identifier>key_from_value</span> <span class=identifier>key_extractor</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>key_compare</span> <span class=identifier>key_comp</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>value_compare</span> <span class=identifier>value_comp</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// set operations:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>find</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>count</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>lower_bound</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>lower_bound</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>upper_bound</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>iterator</span> <span class=identifier>upper_bound</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>equal_range</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// range:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>LowerBounder</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>UpperBounder</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>></span> <span class=identifier>range</span><span class=special>(</span>
+ <span class=identifier>LowerBounder</span> <span class=identifier>lower</span><span class=special>,</span><span class=identifier>UpperBounder</span> <span class=identifier>upper</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// rank operations:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>nth</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>rank</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>find_rank</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>find_rank</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>lower_bound_rank</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>lower_bound_rank</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>upper_bound_rank</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>size_type</span> <span class=identifier>upper_bound_rank</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>size_type</span><span class=special>,</span><span class=identifier>size_type</span><span class=special>></span> <span class=identifier>equal_range_rank</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompatibleKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompatibleCompare</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>size_type</span><span class=special>,</span><span class=identifier>size_type</span><span class=special>></span> <span class=identifier>equal_range_rank</span><span class=special>(</span>
+ <span class=keyword>const</span> <span class=identifier>CompatibleKey</span><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>CompatibleCompare</span><span class=special>&</span> <span class=identifier>comp</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>LowerBounder</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>UpperBounder</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>size_type</span><span class=special>,</span><span class=identifier>size_type</span><span class=special>></span>
+ <span class=identifier>range_rank</span><span class=special>(</span><span class=identifier>LowerBounder</span> <span class=identifier>lower</span><span class=special>,</span><span class=identifier>UpperBounder</span> <span class=identifier>upper</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+<span class=special>};</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>==(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>size</span><span class=special>()==</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>size</span><span class=special>()&&</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>lexicographical_compare</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>!=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>==</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>y</span><span class=special><</span><span class=identifier>x</span><span class=special>;</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special><</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>></span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity_signature">Complexity signature</a></h4>
+
+<p>
+We follow the terminology described in the
+<a href="indices.html#complexity_signature">complexity signature
+section</a>. The complexity signature of ranked indices is:
+<ul>
+ <li>copying: <code>c(n)=n*log(n)</code>,</li>
+ <li>insertion: <code>i(n)=log(n)</code>,</li>
+ <li>hinted insertion: <code>h(n)=1</code> (constant) if the hint element
+ is immediately after the point of insertion, <code>h(n)=log(n)</code> otherwise,</li>
+ <li>deletion: <b><code>d(n)=log(n)</code></b> ,</li>
+ <li>replacement: <code>r(n)=1</code> (constant) if the element position does not
+ change, <code>r(n)=log(n)</code> otherwise,</li>
+ <li>modifying: <code>m(n)=1</code> (constant) if the element position does not
+ change, <code>m(n)=log(n)</code> otherwise.</li>
+</ul>
+</p>
+<p>
+These complexity guarantees are the same as those of
+<a href="ord_indices.html#complexity_signature">ordered indices</a>
+except for deletion, which is <code>log(n)</code> here and amortized constant there.
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>Ordered indices are instantiated internally to <code>multi_index_container</code> and
+specified by means of <a href="indices.html#indexed_by"><code>indexed_by</code></a>
+with <a href="#unique_non_unique"> index specifiers <code>ranked_unique</code>
+and <code>ranked_non_unique</code></a>. Instantiations are dependent on the
+following types:
+<ul>
+ <li><code>Value</code> from <code>multi_index_container</code>,</li>
+ <li><code>Allocator</code> from <code>multi_index_container</code>,</li>
+ <li><code>TagList</code> from the index specifier (if provided, otherwise <code>tag<></code> is assumed),</li>
+ <li><code>KeyFromValue</code> from the index specifier,</li>
+ <li><code>Compare</code> from the index specifier.</li>
+</ul>
+These types are subject to the same requirements as specified for
+<a href="ord_indices.html#instantiation_types">ordered indices</a>.
+</p>
+
+<h4><a name="rank_operations">Rank operations</a></h4>
+
+<p>
+The <i>rank</i> of an iterator <code>it</code> of a given container <code>c</code> (and,
+by extension, of the element it points to if the iterator is dereferenceable)
+is <code>std::distance(c.begin(),it)</code>.
+</p>
+
+<p>
+See the documentation of ordered indices for an explanation of the notions of
+<a href="ord_indices.html#set_operations"><i>compatible extension</i>,
+<i>compatible key</i></a>,
+<a href="ord_indices.html#range_operations"><i>lower bounder</i> and <i>upper bounder</i></a>, which are
+referred to below.
+</p>
+
+<code>iterator nth(size_type n)const;</code>
+
+<blockquote>
+<b>Effects:</b> Returns an iterator with rank <code>n</code>,
+or <code>end()</code> if <code>n>=size()</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>size_type rank(iterator position)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Returns the rank of <code>position</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey> size_type find_rank(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(find(k))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+size_type find_rank(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(find(x,comp))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+size_type lower_bound_rank(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(lower_bound(x))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+size_type lower_bound_rank(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(lower_bound(x,comp))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+size_type upper_bound_rank(const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(upper_bound(x))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+size_type upper_bound_rank(const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>rank(upper_bound(x,comp))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey><br>
+std::pair<size_type,size_type> equal_range_rank(<br>
+ const CompatibleKey& x)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>CompatibleKey</code> is a compatible key of
+<code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to <code>make_pair(lower_bound_rank(x),upper_bound_rank(x))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename CompatibleKey,typename CompatibleCompare><br>
+std::pair<size_type,size_type> equal_range_rank(<br>
+ const CompatibleKey& x,const CompatibleCompare& comp)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> (<code>CompatibleKey</code>, <code>CompatibleCompare</code>)
+is a compatible extension of <code>key_compare</code>.<br>
+<b>Effects:</b> Equivalent to
+<code>make_pair(lower_bound_rank(x,comp),upper_bound_rank(x,comp))</code>.<br>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+</blockquote>
+
+<code>template<typename LowerBounder,typename UpperBounder><br>
+std::pair<size_type,size_type> range_rank(<br>
+ LowerBounder lower,UpperBounder upper)const;
+</code>
+
+<blockquote>
+<b>Requires:</b> <code>LowerBounder</code> and <code>UpperBounder</code> are
+a lower and upper bounder of <code>key_compare</code>, respectively.<br>
+<b>Effects:</b> Equivalent to
+<blockquote><pre>
+<span class=keyword>auto</span> <span class=identifier>p</span><span class=special>=</span><span class=identifier>range</span><span class=special>(</span><span class=identifier>lower</span><span class=special>,</span><span class=identifier>upper</span><span class=special>);</span>
+<span class=keyword>return</span> <span class=identifier>make_pair</span><span class=special>(</span><span class=identifier>rank</span><span class=special>(</span><span class=identifier>p</span><span class=special>.</span><span class=identifier>first</span><span class=special>),</span><span class=identifier>rank</span><span class=special>(</span><span class=identifier>p</span><span class=special>.</span><span class=identifier>second</span><span class=special>));</span>
+</pre></blockquote>
+<b>Complexity:</b> <code>O(log(n))</code>.<br>
+<b>Variants:</b> In place of <code>lower</code> or <code>upper</code> (or both),
+the singular value <code>boost::multi_index::unbounded</code> can be
+provided. This acts as a predicate which all values of type <code>key_type</code>
+satisfy.<br>
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+The prerequisites and postconditions associated to serialization of
+<code>multi_index_container</code>s with ranked indices are exactly the same
+as those of <a href="ord_indices.html#serialization">ordered indices</a>.
+
+<hr>
+
+<div class="prev_link"><a href="ord_indices.html"><img src="../prev.gif" alt="ordered_indices" border="0"><br>
+Ordered indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="hash_indices.html"><img src="../next.gif" alt="hashed indices" border="0"><br>
+Hashed indices
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised May 4th 2015</p>
+
+<p>© Copyright 2003-2015 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>
diff --git a/doc/reference/seq_indices.html b/doc/reference/seq_indices.html
new file mode 100644
index 0000000..0240097
--- /dev/null
+++ b/doc/reference/seq_indices.html
@@ -0,0 +1,1065 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
+
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Boost.MultiIndex Documentation - Sequenced indices reference</title>
+<link rel="stylesheet" href="../style.css" type="text/css">
+<link rel="start" href="../index.html">
+<link rel="prev" href="hash_indices.html">
+<link rel="up" href="index.html">
+<link rel="next" href="rnd_indices.html">
+</head>
+
+<body>
+<h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+"middle" width="277" height="86">Boost.MultiIndex Sequenced indices reference</h1>
+
+<div class="prev_link"><a href="hash_indices.html"><img src="../prev.gif" alt="hashed indices" border="0"><br>
+Hashed indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="rnd_indices.html"><img src="../next.gif" alt="random access indices" border="0"><br>
+Random access indices
+</a></div><br clear="all" style="clear: all;">
+
+<hr>
+
+<h2>Contents</h2>
+
+<ul>
+ <li><a href="#seq_index_fwd_synopsis">Header
+ <code>"boost/multi_index/sequenced_index_fwd.hpp"</code> synopsis</a></li>
+ <li><a href="#synopsis">Header
+ <code>"boost/multi_index/sequenced_index.hpp"</code> synopsis</a>
+ <ul>
+ <li><a href="#sequenced"><code>sequenced</code> index specifier</a></li>
+ <li><a href="#seq_indices">Sequenced indices</a>
+ <ul>
+ <li><a href="#complexity_signature">Complexity signature</a></li>
+ <li><a href="#instantiation_types">Instantiation types</a></li>
+ <li><a href="#constructors">Constructors, copy and assignment</a></li>
+ <li><a href="#iterators">Iterators</a></li>
+ <li><a href="#capacity">Capacity operations</a></li>
+ <li><a href="#modifiers">Modifiers</a></li>
+ <li><a href="#list_operations">List operations</a></li>
+ <li><a href="#rearrange_operations">Rearrange operations</a></li>
+ <li><a href="#serialization">Serialization</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+</ul>
+
+<h2>
+<a name="seq_index_fwd_synopsis">Header
+<a href="../../../../boost/multi_index/sequenced_index_fwd.hpp">
+<code>"boost/multi_index/sequenced_index_fwd.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// sequenced index specifier</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>sequenced</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<p>
+<code>sequenced_index_fwd.hpp</code> provides forward declarations for the
+<a href="#sequenced"><code>sequenced</code></a> index specifier and
+its associated <a href="#seq_indices">sequenced index</a> class.
+</p>
+
+<h2>
+<a name="synopsis">Header
+<a href="../../../../boost/multi_index/sequenced_index.hpp">
+<code>"boost/multi_index/sequenced_index.hpp"</code></a> synopsis</a></h2>
+
+<blockquote><pre>
+<span class=preprocessor>#include</span> <span class=special><</span><span class=identifier>initializer_list</span><span class=special>></span>
+
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=comment>// sequenced index specifier</span>
+
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>sequenced</span><span class=special>;</span>
+
+<span class=comment>// indices</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span> <span class=keyword>class</span> <b>index class name implementation defined</b><span class=special>;</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=comment>// <b>OP</b> is any of ==,<,!=,>,>=,<=</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h3><a name="sequenced">
+<code>sequenced</code> index specifier
+</a></h3>
+
+<p>
+This index specifier allows for insertion of a <a href="#seq_indices">sequenced
+index</a>.</p>
+
+<blockquote><pre>
+<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>TagList</span><span class=special>=</span><span class=identifier>tag</span><span class=special><></span> <span class=special>></span> <span class=keyword>struct</span> <span class=identifier>sequenced</span><span class=special>;</span>
+</pre></blockquote>
+
+<p>If provided, <code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>.
+</p>
+
+<h3><a name="seq_indices">Sequenced indices</a></h3>
+
+<p>
+Sequenced indices are modeled after the semantics of a bidirectional list
+like <code>std::list</code>. Elements in a sequenced index are by default
+sorted according to their order of insertion: this means that new elements
+inserted through a different index of the <code>multi_index_container</code> are appended
+to the end of the sequenced index. Additionally, the index allows for free
+reordering of elements in the same vein as <code>std::list</code> does. Validity
+of iterators and references to elements is preserved in all operations.
+</p>
+
+<p>
+Except where noted or if the corresponding interface does not exist, sequenced
+indices verify the same container requirements as <code>std::list</code>:
+we only provide descriptions of those types and operations that are either not
+present in <code>std::list</code> or behave differently. Some of the
+most important differences are:
+<ul>
+ <li>The complexity of some operations, notably insertion and deletion, differ
+ from those of <code>std::list</code>.
+ </li>
+ <li>Unlike as in <code>std::list</code>, insertions into a sequenced index
+ may fail due to clashings with other indices. This alters the semantics
+ of the operations provided with respect to their analogues in
+ <code>std::list</code>.
+ </li>
+ <li>Elements in a sequenced index are not mutable, and can only be changed
+ by means of <a href="#replace"><code>replace</code></a> and
+ <a href="#modify"><code>modify</code></a> member functions.
+ </li>
+</ul>
+</p>
+
+<blockquote><pre>
+<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
+
+<span class=keyword>namespace</span> <span class=identifier>detail</span><span class=special>{</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined: dependent on types Value, Allocator, TagList</b><span class=special>></span>
+<span class=keyword>class</span> <b>name is implementation defined</b>
+<span class=special>{</span>
+<span class=keyword>public</span><span class=special>:</span>
+ <span class=comment>// types:</span>
+
+ <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuples</span><span class=special>::</span><span class=identifier>null_type</span> <span class=identifier>ctor_args</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>TagList</span> <span class=identifier>tag_list</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>Allocator</span> <span class=identifier>allocator_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>reference</span> <span class=identifier>reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>const_reference</span> <span class=identifier>const_reference</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>const_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>size_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>ptrdiff_t</span> <span class=identifier>difference_type</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>pointer</span> <span class=identifier>pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>allocator_type</span><span class=special>::</span><span class=identifier>const_pointer</span> <span class=identifier>const_pointer</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<iterator></b> <span class=identifier>reverse_iterator</span><span class=special>;</span>
+ <span class=keyword>typedef</span> <b>equivalent to
+ std::reverse_iterator<const_iterator></b> <span class=identifier>const_reverse_iterator</span><span class=special>;</span>
+
+ <span class=comment>// construct/copy/destroy:</span>
+
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <b>index class name</b><span class=special>&</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>class</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>assign</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>value</span><span class=special>);</span>
+
+ <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// iterators:</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>begin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>end</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>rend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>cend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crbegin</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>const_reverse_iterator</span> <span class=identifier>crend</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>const_iterator</span> <span class=identifier>iterator_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// capacity:</span>
+
+ <span class=keyword>bool</span> <span class=identifier>empty</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+ <span class=identifier>size_type</span> <span class=identifier>max_size</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=keyword>void</span> <span class=identifier>resize</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>resize</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=comment>// access:</span>
+
+ <span class=identifier>const_reference</span> <span class=identifier>front</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+ <span class=identifier>const_reference</span> <span class=identifier>back</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
+
+ <span class=comment>// modifiers:</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace_front</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_front</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_front</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>pop_front</span><span class=special>();</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace_back</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_back</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>push_back</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>pop_back</span><span class=special>();</span>
+
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>></span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>emplace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Args</span><span class=special>&&...</span> <span class=identifier>args</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special><</span><span class=identifier>iterator</span><span class=special>,</span><span class=keyword>bool</span><span class=special>></span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>size_type</span> <span class=identifier>n</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>InputIterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>insert</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special><</span><span class=identifier>value_type</span><span class=special>></span> <span class=identifier>list</span><span class=special>);</span>
+
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>);</span>
+ <span class=identifier>iterator</span> <span class=identifier>erase</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>bool</span> <span class=identifier>replace</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>value_type</span><span class=special>&&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>></span> <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Modifier</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Rollback</span><span class=special>></span>
+ <span class=keyword>bool</span> <span class=identifier>modify</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>Modifier</span> <span class=identifier>mod</span><span class=special>,</span><span class=identifier>Rollback</span> <span class=identifier>back</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>clear</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// list operations:</span>
+
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>i</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>splice</span><span class=special>(</span>
+ <span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>remove</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&</span> <span class=identifier>value</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Predicate</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>remove_if</span><span class=special>(</span><span class=identifier>Predicate</span> <span class=identifier>pred</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>unique</span><span class=special>();</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>class</span> <span class=identifier>BinaryPredicate</span><span class=special>></span>
+ <span class=keyword>void</span> <span class=identifier>unique</span><span class=special>(</span><span class=identifier>BinaryPredicate</span> <span class=identifier>binary_pred</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>merge</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>);</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>merge</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>Compare</span> <span class=identifier>comp</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>sort</span><span class=special>();</span>
+ <span class=keyword>template</span> <span class=special><</span><span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>sort</span><span class=special>(</span><span class=identifier>Compare</span> <span class=identifier>comp</span><span class=special>);</span>
+
+ <span class=keyword>void</span> <span class=identifier>reverse</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
+
+ <span class=comment>// rearrange operations:</span>
+
+ <span class=keyword>void</span> <span class=identifier>relocate</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>i</span><span class=special>);</span>
+ <span class=keyword>void</span> <span class=identifier>relocate</span><span class=special>(</span><span class=identifier>iterator</span> <span class=identifier>position</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>first</span><span class=special>,</span><span class=identifier>iterator</span> <span class=identifier>last</span><span class=special>);</span>
+ <span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>></span> <span class=keyword>void</span> <span class=identifier>rearrange</span><span class=special>(</span><span class=identifier>InputIterator</span> <span class=identifier>first</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index comparison:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>==(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>size</span><span class=special>()==</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>size</span><span class=special>()&&</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>equal</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>lexicographical_compare</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>y</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>!=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>==</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span>
+ <span class=special>,</span><span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=identifier>y</span><span class=special><</span><span class=identifier>x</span><span class=special>;</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>>=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special><</span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=keyword>template</span><span class=special><</span><b>arg set 1</b><span class=special>,</span><b>arg set 2</b><span class=special>></span>
+<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special><=(</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 1</b><span class=special>>&</span> <span class=identifier>x</span><span class=special>,</span>
+ <span class=keyword>const</span> <b>index class name</b><span class=special><</span><b>arg set 2</b><span class=special>>&</span> <span class=identifier>y</span><span class=special>)</span>
+<span class=special>{</span>
+ <span class=keyword>return</span> <span class=special>!(</span><span class=identifier>x</span><span class=special>></span><span class=identifier>y</span><span class=special>);</span>
+<span class=special>}</span>
+
+<span class=comment>// index specialized algorithms:</span>
+
+<span class=keyword>template</span><span class=special><</span><b>implementation defined</b><span class=special>></span>
+<span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><b>index class name</b><span class=special>&</span> <span class=identifier>x</span><span class=special>,</span><b>index class name</b><span class=special>&</span> <span class=identifier>y</span><span class=special>);</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index::detail</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
+
+<span class=special>}</span> <span class=comment>// namespace boost</span>
+</pre></blockquote>
+
+<h4><a name="complexity_signature">Complexity signature</a></h4>
+
+<p>
+Here and in the descriptions of operations of sequenced indices, we adopt the
+scheme outlined in the
+<a href="indices.html#complexity_signature">complexity signature
+section</a>. The complexity signature of sequenced indices is:
+<ul>
+ <li>copying: <code>c(n)=n*log(n)</code>,</li>
+ <li>insertion: <code>i(n)=1</code> (constant),</li>
+ <li>hinted insertion: <code>h(n)=1</code> (constant),</li>
+ <li>deletion: <code>d(n)=1</code> (constant),</li>
+ <li>replacement: <code>r(n)=1</code> (constant),</li>
+ <li>modifying: <code>m(n)=1</code> (constant).</li>
+</ul>
+</p>
+
+<h4><a name="instantiation_types">Instantiation types</a></h4>
+
+<p>Sequenced indices are instantiated internally to <code>multi_index_container</code>
+and specified by means of <a href="indices.html#indexed_by">
+<code>indexed_by</code></a> with the <a href="#sequenced"><code>sequenced</code></a>
+index specifier. Instantiations are dependent on the following types:
+<ul>
+ <li><code>Value</code> from <code>multi_index_container</code>,</li>
+ <li><code>Allocator</code> from <code>multi_index_container</code>,</li>
+ <li><code>TagList</code> from the index specifier (if provided, otherwise <code>tag<></code> is assumed).</li>
+</ul>
+<code>TagList</code> must be an instantiation of
+<a href="indices.html#tag"><code>tag</code></a>.
+</p>
+
+<h4><a name="constructors">Constructors, copy and assignment</a></h4>
+
+<p>
+As explained in the <a href="indices.html#index_concepts">index
+concepts section</a>, indices do not have public constructors or destructors.
+Assignment, on the other hand, is provided.
+</p>
+
+<code><b>index class name</b>& operator=(const <b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>b</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> and <code>b</code> are the <code>multi_index_container</code>
+objects to which <code>*this</code> and <code>x</code> belong, respectively.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code><b>index class name</b>& operator=(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>a</span><span class=special>=</span><span class=identifier>list</span><span class=special>;</span>
+</pre></blockquote>
+where <code>a</code> is the <code>multi_index_container</code>
+object to which <code>*this</code> belongs.<br>
+<b>Returns:</b> <code>*this</code>.<br>
+</blockquote>
+
+<code>template <class InputIterator><br>
+void assign(InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>clear</span><span class=special>();</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>first</span><span class=special>,</span><span class=identifier>last</span><span class=special>);</span>
+</pre></blockquote>
+</blockquote>
+
+<code>void assign(std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>assign</span><span class=special>(</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+</pre></blockquote>
+</blockquote>
+
+<code>void assign(size_type n,const value_type& value);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>clear</span><span class=special>();</span>
+<span class=keyword>for</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>i</span><span class=special>=</span><span class=number>0</span><span class=special>;</span><span class=identifier>i</span><span class=special><</span><span class=identifier>n</span><span class=special>;++</span><span class=identifier>n</span><span class=special>)</span><span class=identifier>push_back</span><span class=special>(</span><span class=identifier>v</span><span class=special>);</span>
+</pre></blockquote>
+</blockquote>
+
+<h4><a name="iterators">Iterators</a></h4>
+
+<code>iterator iterator_to(const value_type& x);<br>
+const_iterator iterator_to(const value_type& x)const;</code>
+
+<blockquote>
+<b>Requires:</b> <code>x</code> is a reference to an element of the container.<br>
+<b>Returns:</b> An iterator to <code>x</code>.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<h4><a name="capacity">Capacity operations</a></h4>
+
+<code>void resize(size_type n);<br>
+void resize(size_type n,const value_type& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>DefaultInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.<br>
+<b>Effects:</b> If <code>size()<n</code>, tries to append <code>n-size()</code> default-inserted
+elements (first version) or copies of <code>x</code> (second version) at the end of
+the index. If <code>n<size()</code>, erases the last <code>size()-n</code> elements.<br>
+<b>Note:</b> If an expansion is requested, the size of the index is not guaranteed
+to be <code>n</code> after this operation (other indices may ban insertions.)
+</blockquote>
+
+<h4><a name="modifiers">Modifiers</a></h4>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace_front(Args&&... args);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>emplace</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>forward</span><span class=special><</span><span class=identifier>Args</span><span class=special>>(</span><span class=identifier>args</span><span class=special>)...);</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> push_front(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> push_front(value_type&& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>x</span><span class=special>);</span> <span class=comment>// lvalue ref version</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>move</span><span class=special>(</span><span class=identifier>x</span><span class=special>));</span> <span class=comment>// rvalue ref version</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+std::pair<iterator,bool> emplace_back(Args&&... args);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>emplace</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>forward</span><span class=special><</span><span class=identifier>Args</span><span class=special>>(</span><span class=identifier>args</span><span class=special>)...);</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> push_back(const value_type& x);</code><br>
+<code>std::pair<iterator,bool> push_back(value_type&& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>x</span><span class=special>);</span> <span class=comment>// lvalue ref version</span>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>end</span><span class=special>(),</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>move</span><span class=special>(</span><span class=identifier>x</span><span class=special>));</span> <span class=comment>// rvalue ref version</span>
+</pre></blockquote>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+</blockquote>
+
+<code>template<typename... Args><br>
+ std::pair<iterator,bool> emplace(iterator position,Args&&... args);</code>
+
+<blockquote>
+<b>Requires:</b> <code>value_type</code> is <code>EmplaceConstructible</code>
+into <code>multi_index_container</code> from <code>args</code>.<br>
+<b>Effects:</b> Inserts a <code>value_type</code> object constructed with
+<code>std::forward<Args>(args)...</code> before <code>position</code> if insertion
+is allowed by all other indices of the <code>multi_index_container</code>.<br>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful insertion,
+<code>p.first</code> points to the element inserted; otherwise, <code>p.first</code>
+points to an element that caused the insertion to be banned. Note that more than
+one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.<br>
+</blockquote>
+
+<code>std::pair<iterator,bool> insert(iterator position,const value_type& x);</code><br>
+<code>std::pair<iterator,bool> insert(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveInsertable</code>
+into <code>multi_index_container</code>.
+<code>position</code> is a valid iterator of the index.<br>
+<b>Effects:</b> Inserts <code>x</code> before <code>position</code> if insertion
+is allowed by all other indices of the <code>multi_index_container</code>.<br>
+<b>Returns:</b> The return value is a pair <code>p</code>. <code>p.second</code>
+is <code>true</code> if and only if insertion took place. On successful
+insertion, <code>p.first</code> points to the element inserted; otherwise,
+<code>p.first</code> points to an element that caused the insertion to be banned.
+Note that more than one element can be causing insertion not to be allowed.<br>
+<b>Complexity:</b> <code>O(I(n))</code>.<br>
+<b>Exception safety:</b> Strong.
+</blockquote>
+
+<code>void insert(iterator position,size_type n,const value_type& x);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=keyword>for</span><span class=special>(</span><span class=identifier>size_type</span> <span class=identifier>i</span><span class=special>=</span><span class=number>0</span><span class=special>;</span><span class=identifier>i</span><span class=special><</span><span class=identifier>n</span><span class=special>;++</span><span class=identifier>i</span><span class=special>)</span><span class=identifier>insert</span><span class=special>(</span><span class=identifier>position</span><span class=special>,</span><span class=identifier>x</span><span class=special>);</span>
+</pre></blockquote>
+</blockquote>
+
+<code>template<typename InputIterator><br>
+void insert(iterator position,InputIterator first,InputIterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>InputIterator</code> is an input iterator.
+<code>value_type</code> is
+<code>EmplaceConstructible</code> into
+<code>multi_index_container</code> from <code>*first</code>.
+<code>first</code> and <code>last</code> are not iterators into any
+index of the <code>multi_index_container</code> to which this index belongs.
+<code>last</code> is reachable from <code>first</code>.<br>
+<b>Effects:</b>
+For each element of [<code>first</code>, <code>last</code>), in this
+order, inserts it before <code>position</code> if insertion is allowed by all
+other indices of the <code>multi_index_container</code>.<br>
+<b>Complexity:</b> <code>O(m*I(n+m))</code>, where <code>m</code> is the
+number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void insert(iterator position,std::initializer_list<value_type> list);</code>
+
+<blockquote>
+<b>Effects:</b>
+<blockquote><pre>
+<span class=identifier>insert</span><span class=special>(</span><span class=identifier>position</span><span class=special>,</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span><span class=identifier>list</span><span class=special>.</span><span class=identifier>end</span><span class=special>());</span>
+</pre></blockquote>
+</blockquote>
+
+<code>iterator erase(iterator position);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid dereferenceable iterator
+of the index.<br>
+<b>Effects:</b> Deletes the element pointed to by <code>position</code>.<br>
+<b>Returns:</b> An iterator pointing to the element immediately following
+the one that was deleted, or <code>end()</code>
+if no such element exists.<br>
+<b>Complexity:</b> <code>O(D(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>iterator erase(iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> [<code>first</code>,<code>last</code>) is a valid
+range of the index.<br>
+<b>Effects:</b> Deletes the elements in [<code>first</code>,<code>last</code>).<br>
+<b>Returns:</b> <code>last</code>.<br>
+<b>Complexity:</b> <code>O(m*D(n))</code>, where <code>m</code> is
+the number of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="replace"><code>bool replace(iterator position,const value_type& x);</code></a><br>
+<code>bool replace(iterator position,value_type&& x);</code>
+
+<blockquote>
+<b>Requires (first version):</b> <code>value_type</code> is <code>CopyAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Requires (second version):</b> <code>value_type</code> is <code>MoveAssignable</code>.
+<code>position</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Assigns the value <code>x</code> to the element pointed
+to by <code>position</code> into the <code>multi_index_container</code> to which
+the index belongs if replacing is allowed by all other indices of the
+<code>multi_index_container</code>.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved
+in all cases.<br>
+<b>Returns:</b> <code>true</code> if the replacement took place,
+<code>false</code> otherwise.<br>
+<b>Complexity:</b> <code>O(R(n))</code>.<br>
+<b>Exception safety:</b> Strong. If an exception is thrown by some
+user-provided operation the <code>multi_index_container</code> to which the index
+belongs remains in its original state.
+</blockquote>
+
+<a name="modify">
+<code>template<typename Modifier> bool modify(iterator position,Modifier mod);</code></a>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> is a unary function object
+accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and rearranges <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement on sequenced
+indices does not change the position of the element with respect to the index;
+rearrangement on other indices may or might not succeed. If the rearrangement
+fails, the element is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved if the
+operation succeeds.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Basic. If an exception is thrown by some
+user-provided operation (including <code>mod</code>), then
+the element pointed to by <code>position</code> is erased.
+</blockquote>
+
+<code>template<typename Modifier,typename Rollback><br>
+bool modify(iterator position,Modifier mod,Rollback back);</code>
+
+<blockquote>
+<b>Requires:</b> <code>mod</code> and <code>back</code> are unary function
+objects accepting arguments of type
+<code>value_type&</code>. <code>position</code> is a valid dereferenceable
+iterator of the index.
+The execution of <code>mod(e)</code>, where <code>e</code> is the element
+pointed to by <code>position</code>, does not invoke any operation of the
+<code>multi_index_container</code> after <code>e</code> is directly modified
+or, before modification, if the operation would invalidate <code>position</code>.
+<code>back(e)</code> does not invoke any operation of the
+<code>multi_index_container</code>.<br>
+<b>Effects:</b> Calls <code>mod(e)</code> where <code>e</code> is the element
+pointed to by <code>position</code> and tries to rearrange <code>*position</code> into
+all the indices of the <code>multi_index_container</code>. Rearrangement on sequenced
+indices does not change the position of the element with respect to the index;
+rearrangement on other indices may or might not succeed.
+If the rearrangement fails, <code>back(e)</code> is invoked: if the resulting value
+of <code>e</code> is consistent with its original position and constraints in all
+indices, the element is kept, otherwise it is erased.<br>
+<b>Postconditions:</b> Validity of <code>position</code> is preserved except if
+the element is erased under the conditions described below.<br>
+<b>Returns:</b> <code>true</code> if the operation succeeded, <code>false</code>
+otherwise.<br>
+<b>Complexity:</b> <code>O(M(n))</code>.<br>
+<b>Exception safety:</b> Strong, except if <code>mod</code> or <code>back</code> throw an
+exception or <code>back(e)</code> fails to properly restore the element or there is
+a throwing user-provided operation after invoking <code>back(e)</code>, in which cases
+the modified element is erased. If <code>back</code>
+throws inside the handling code executing after some other user-provided
+operation has thrown, it is the exception generated by <code>back</code> that
+is rethrown.
+</blockquote>
+
+<h4><a name="list_operations">List operations</a></h4>
+
+<p>
+Sequenced indices provide the full set of list operations found in
+<code>std::list</code>; the semantics of these member functions, however,
+differ from that of <code>std::list</code> in some cases as insertions
+might not succeed due to banning by other indices. Similarly, the complexity
+of the operations may depend on the other indices belonging to the
+same <code>multi_index_container</code>.
+</p>
+
+<code>void splice(iterator position,<b>index class name</b>& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>&x!=this</code>.<br>
+<b>Effects:</b> Inserts the contents of <code>x</code> before <code>position</code>,
+in the same order as they were in <code>x</code>. Those elements successfully
+inserted are erased from <code>x</code>.<br>
+<b>Complexity:</b> <code>O(x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<code>void splice(iterator position,<b>index class name</b>& x,iterator i);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>i</code> is a valid dereferenceable iterator <code>x</code>.<br>
+<b>Effects:</b> Inserts the element pointed to by <code>i</code> before
+<code>position</code>: if insertion is successful, the element is erased from
+<code>x</code>. In the special case <code>&x==this</code>, no copy or
+deletion is performed, and the operation is always successful. If
+<code>position==i</code>, no operation is performed.<br>
+<b>Postconditions:</b> If <code>&x==this</code>, no iterator or reference
+is invalidated.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(I(n) + D(n))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, strong.<br>
+</blockquote>
+
+<code>void splice(iterator position,<b>index class name&</b> x,iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>first</code> and <code>last</code> are valid iterators of <code>x</code>.
+<code>last</code> is reachable from <code>first</code>. <code>position</code>
+is not in the range [<code>first</code>,<code>last</code>).<br>
+<b>Effects:</b> For each element in the range [<code>first</code>,<code>last</code>),
+insertion is tried before <code>position</code>; if the operation is successful,
+the element is erased from <code>x</code>. In the special case
+<code>&x==this</code>, no copy or deletion is performed, and insertions are
+always successful.<br>
+<b>Postconditions:</b> If <code>&x==this</code>, no iterator or reference
+is invalidated.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(m*I(n+m) + m*D(x.size()))</code> where <code>m</code> is the number
+of elements in [<code>first</code>,<code>last</code>).<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>void remove(const value_type& value);</code>
+
+<blockquote>
+<b>Effects:</b> Erases all elements of the index which compare equal to
+<code>value</code>.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>template<typename Predicate> void remove_if(Predicate pred);</code>
+
+<blockquote>
+<b>Effects:</b> Erases all elements <code>x</code> of the index for which
+<code>pred(x)</code> holds.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void unique();</code>
+
+<blockquote>
+<b>Effects:</b> Eliminates all but the first element from every consecutive
+group of equal elements referred to by the iterator <code>i</code> in the range
+[<code>first+1</code>,<code>last</code>) for which <code>*i==*(i-1)</code>.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);</code>
+
+<blockquote>
+<b>Effects:</b> Eliminates all but the first element from every consecutive
+group of elements referred to by the iterator <code>i</code> in the range
+[<code>first+1</code>,<code>last</code>) for which
+<code>binary_pred(*i,*(i-1))</code> holds.<br>
+<b>Complexity:</b> <code>O(n + m*D(n))</code>, where <code>m</code>
+is the number of elements erased.<br>
+<b>Exception safety:</b> Basic.
+</blockquote>
+
+<code>void merge(index class name& x);</code>
+
+<blockquote>
+<b>Requires:</b> <code>std::less<value_type></code> induces a
+strict weak ordering over <code>value_type</code>.
+Both the index and <code>x</code> are sorted according to
+<code>std::less<value_type></code>.<br>
+<b>Effects:</b> Attempts to insert every element of <code>x</code> into the
+corresponding position of the index (according to the order). Elements
+successfully inserted are erased from <code>x</code>. The resulting sequence
+is stable, i.e. equivalent elements of either container preserve their
+relative position. In the special case <code>&x==this</code>, no operation
+is performed.<br>
+<b>Postconditions:</b> Elements in the index and remaining elements in
+<code>x</code> are sorted.
+Validity of iterators to the index and of non-erased elements of <code>x</code>
+references is preserved.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(n + x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>template <typename Compare> void merge(index class name& x,Compare comp);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Compare</code> induces a
+strict weak ordering over <code>value_type</code>.
+Both the index and <code>x</code> are sorted according to <code>comp</code>.<br>
+<b>Effects:</b> Attempts to insert every element of <code>x</code> into the
+corresponding position of the index (according to <code>comp</code>).
+Elements successfully inserted are erased from <code>x</code>. The resulting
+sequence is stable, i.e. equivalent elements of either container preserve
+their relative position. In the special case <code>&x==this</code>, no
+operation is performed.<br>
+<b>Postconditions:</b> Elements in the index and remaining elements in
+<code>x</code> are sorted according to <code>comp</code>.
+Validity of iterators to the index and of non-erased elements of <code>x</code>
+references is preserved.<br>
+<b>Complexity:</b> If <code>&x==this</code>, constant; otherwise
+<code>O(n + x.size()*I(n+x.size()) + x.size()*D(x.size()))</code>.<br>
+<b>Exception safety:</b> If <code>&x==this</code>, <code>nothrow</code>;
+otherwise, basic.<br>
+</blockquote>
+
+<code>void sort();</code>
+
+<blockquote>
+<b>Requires:</b> <code>std::less<value_type></code> induces a
+strict weark ordering over <code>value_type</code>.<br>
+<b>Effects:</b> Sorts the index according to
+<code>std::less<value_type></code>. The sorting is stable, i.e.
+equivalent elements preserve their relative position.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n*log(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code> if
+<code>std::less<value_type></code> does not throw; otherwise, basic.
+</blockquote>
+
+<code>template <typename Compare> void sort(Compare comp);</code>
+
+<blockquote>
+<b>Requires:</b> <code>Compare</code> induces a
+strict weak ordering over <code>value_type</code>.<br>
+<b>Effects:</b> Sorts the index according to <code>comp</code>. The sorting
+is stable, i.e. equivalent elements preserve their relative position.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n*log(n))</code>.<br>
+<b>Exception safety:</b> <code>nothrow</code> if <code>comp</code> does
+not throw; otherwise, basic.
+</blockquote>
+
+<code>void reverse()noexcept;</code>
+
+<blockquote>
+<b>Effects:</b> Reverses the order of the elements in the index.<br>
+<b>Postconditions:</b> Validity of iterators and references is preserved.<br>
+<b>Complexity:</b> <code>O(n)</code>.<br>
+</blockquote>
+
+<h4><a name="rearrange_operations">Rearrange operations</a></h4>
+
+<p>
+These operations, without counterpart in <code>std::list</code>
+(although <code>splice</code> provides partially overlapping
+functionality), perform individual and global repositioning of elements
+inside the index.
+</p>
+
+<code>void relocate(iterator position,iterator i);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>i</code> is a valid dereferenceable iterator of the index.<br>
+<b>Effects:</b> Inserts the element pointed to by <code>i</code> before
+<code>position</code>. If <code>position==i</code>, no operation is
+performed.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<code>void relocate(iterator position,iterator first,iterator last);</code>
+
+<blockquote>
+<b>Requires:</b> <code>position</code> is a valid iterator of the index.
+<code>first</code> and <code>last</code> are valid iterators of the index.
+<code>last</code> is reachable from <code>first</code>. <code>position</code>
+is not in the range [<code>first</code>,<code>last</code>).<br>
+<b>Effects:</b> The range of elements [<code>first</code>,<code>last</code>)
+is repositioned just before <code>position</code>.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> Constant.<br>
+<b>Exception safety:</b> <code>nothrow</code>.<br>
+</blockquote>
+
+<a name="rearrange"><code>template<typename InputIterator> void rearrange(InputIterator first);</code></a>
+
+<blockquote>
+<b>Requires:</b> The range [<code>first</code>,
+<code>std::advance(first,n)</code>),
+where <code>n</code> is the size of the index, is a
+<a href="indices.html#views">free view</a> of the index.<br>
+<b>Effects:</b> The elements are rearranged so as to match the
+order of the previously described view.<br>
+<b>Postconditions:</b> No iterator or reference is invalidated.<br>
+<b>Complexity:</b> <code>O(n)</code>.<br>
+<b>Exception safety:</b> Basic.<br>
+</blockquote>
+
+<h4><a name="serialization">Serialization</a></h4>
+
+<p>
+Indices cannot be serialized on their own, but only as part of the
+<code>multi_index_container</code> into which they are embedded. In describing
+the additional preconditions and guarantees associated to sequenced indices
+with respect to serialization of their embedding containers, we
+use the concepts defined in the <code>multi_index_container</code>
+<a href="multi_index_container.html#serialization">serialization section</a>.
+</p>
+
+Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
+output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.
+</blockquote>
+
+Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
+input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> No additional requirements to those imposed by the container.<br>
+<b>Postconditions:</b> On successful loading, each of the elements of
+[<code>begin()</code>, <code>end()</code>) is a restored copy of the corresponding
+element in [<code>m.get<i>().begin()</code>, <code>m.get<i>().end()</code>),
+where <code>i</code> is the position of the sequenced index in the container.
+</blockquote>
+
+Operation: saving of an <code>iterator</code> or <code>const_iterator</code>
+<code>it</code> to an output archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Requires:</b> <code>it</code> is a valid iterator of the index. The associated
+<code>multi_index_container</code> has been previously saved.
+</blockquote>
+
+Operation: loading of an <code>iterator</code> or <code>const_iterator</code>
+<code>it'</code> from an input archive (XML archive) <code>ar</code>.
+
+<blockquote>
+<b>Postconditions:</b> On successful loading, if <code>it</code> was dereferenceable
+then <code>*it'</code> is the restored copy of <code>*it</code>, otherwise
+<code>it'==end()</code>.<br>
+<b>Note:</b> It is allowed that <code>it</code> be a <code>const_iterator</code>
+and the restored <code>it'</code> an <code>iterator</code>, or viceversa.
+</blockquote>
+
+<hr>
+
+<div class="prev_link"><a href="hash_indices.html"><img src="../prev.gif" alt="hashed indices" border="0"><br>
+Hashed indices
+</a></div>
+<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
+Boost.MultiIndex reference
+</a></div>
+<div class="next_link"><a href="rnd_indices.html"><img src="../next.gif" alt="random access indices" border="0"><br>
+Random access indices
+</a></div><br clear="all" style="clear: all;">
+
+<br>
+
+<p>Revised August 24th 2017</p>
+
+<p>© Copyright 2003-2017 Joaquín M López Muñoz.
+Distributed under the Boost Software
+License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
+LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
+
+</body>
+</html>