merged from trunk to branch

[SVN r34527]

doc/compiler_specifics.html

@@ -590,7 +590,7 @@ objects of derived types. For instance:
 Problems have been reported when compiling the library with the <code>/Gm</code>
 option (Enable Minimal Rebuild.) Seemingly, this is due to an
 internal defect of the compiler (see for instance
-<a href="http://lists.boost.org/MailArchives/boost-users/msg05988.php">
+<a href="http://lists.boost.org/boost-users/2004/02/5987.php">
 this mention of a similar issue</a> in the Boost Users mailing list.)
 If <code>/Gm</code> is turned off, Boost.MultiIndex compiles and runs
 without further problems.
@@ -1030,7 +1030,7 @@ Performance
 
 <br>
 
-<p>Revised February 6th 2006</p>
+<p>Revised July 13th 2006</p>
 
 <p>&copy; Copyright 2003-2006 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 Distributed under the Boost Software 

doc/reference/hash_indices.html

@@ -655,7 +655,7 @@ Consider a pair (<code>Hash</code>, <code>Pred</code>) where
 and <code>Pred</code> is a
 <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">
 <code>Binary Predicate</code></a> inducing an equivalence relation
-on <code>Key</code>, whit the additional constraint that equivalent
+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>
@@ -804,7 +804,7 @@ load factor, and <code>bucket_count()>=n</code>.<br>
 elements contained is preserved.<br>
 <b>Complexity:</b> Average case <code>O(size())</code>, worst case
 <code>O(size(n)<sup>2</sup>)</code>.<br>
-<b>Exeption safety:</b> Strong.
+<b>Exception safety:</b> Strong.
 </blockquote>
 
 <h4><a name="serialization">Serialization</a></h4>
@@ -895,7 +895,7 @@ Sequenced indices
 
 <br>
 
-<p>Revised February 6th 2006</p>
+<p>Revised July 13th 2006</p>
 
 <p>&copy; Copyright 2003-2006 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 Distributed under the Boost Software 

doc/reference/key_extraction.html

@@ -215,7 +215,7 @@ that acts as a do-nothing identity functor.
 <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=comment>// only provided if const ChainedPtr&amp; is not convertible to const Type&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</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>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> 
@@ -324,7 +324,7 @@ aimed at accessing a given member of a class.
 <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=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</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>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
@@ -416,7 +416,7 @@ luckily enough, most compilers accept it nevertheless, so
 <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=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</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>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> 
@@ -521,7 +521,7 @@ returning as key the result of invoking a given constant member function of a cl
 <span class=special>{</span>
   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</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=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</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>&amp;</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>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
@@ -593,7 +593,7 @@ returning as key the result of invoking a given member function of a class.
 <span class=special>{</span>
   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</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=comment>// only provided if ChainedPtr&amp; is not convertible to Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</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>&amp;</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>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
@@ -656,7 +656,7 @@ these pointers as an additional template parameter.
 <span class=special>{</span>
   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</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=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</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>&amp;</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>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
@@ -700,7 +700,7 @@ used for extraction.
 <span class=special>{</span>
   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</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=comment>// only provided if ChainedPtr&amp; is not convertible to Class&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</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>&amp;</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>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
@@ -886,7 +886,7 @@ at compile time. The returned object is of type
   <span class=keyword>const</span> <span class=identifier>key_extractor_tuple</span><span class=special>&amp;</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>&amp;</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=comment>// only provided if const ChainedPtr&amp; is not convertible to const value_type&amp;</span>
   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</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>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
   
@@ -2101,7 +2101,7 @@ Compiler specifics
 
 <br>
 
-<p>Revised April 17th 2006</p>
+<p>Revised July 13th 2006</p>
 
 <p>&copy; Copyright 2003-2006 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 Distributed under the Boost Software 

doc/tutorial/basics.html

@@ -1034,10 +1034,10 @@ indices with respect to <code>std::list</code>s, namely that elements of an
 <span class=identifier>multi_index_container</span><span class=special>&lt;</span>
   <span class=keyword>int</span><span class=special>,</span>
   <span class=identifier>indexed_by</span><span class=special>&lt;</span><span class=identifier>sequenced</span><span class=special>&lt;&gt;</span> <span class=special>&gt;</span>
-<span class=special>&gt;</span> <span class=identifier>s</span><span class=special>;</span>             <span class=comment>// list-like container</span>
+<span class=special>&gt;</span> <span class=identifier>s</span><span class=special>;</span>            <span class=comment>// list-like container</span>
 
 <span class=identifier>s</span><span class=special>.</span><span class=identifier>push_front</span><span class=special>(</span><span class=number>0</span><span class=special>);</span>
-<span class=special>*(</span><span class=identifier>s</span><span class=special>.</span><span class=identifier>begin</span><span class=special>())==</span><span class=number>1</span><span class=special>;</span> <span class=comment>// ERROR: the element cannot be changed</span>
+<span class=special>*(</span><span class=identifier>s</span><span class=special>.</span><span class=identifier>begin</span><span class=special>())=</span><span class=number>1</span><span class=special>;</span> <span class=comment>// ERROR: the element cannot be changed</span>
 </pre></blockquote>
 
 <p>
@@ -1205,7 +1205,7 @@ Index types
 
 <br>
 
-<p>Revised February 21st 2006</p>
+<p>Revised July 13th 2006</p>
 
 <p>&copy; Copyright 2003-2006 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 Distributed under the Boost Software