feedc0de/boost_concept_check
1
0
Fork 0
forked from boostorg/concept_check
Code Pull Requests Activity

added the Adaptable functor concepts

Browse Source 
also updated the SGI STL URL's


[SVN r11963]
This commit is contained in:
Jeremy Siek
2001-12-06 22:26:22 +00:00
parent 64b2171140
commit f0d2603a67
6 changed files with 64 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
concept_check.htm
View File

@@ -205,7 +205,7 @@ stl_algo.h:1377: no match for `_List_iterator<int,int &,int *> & -
In this case, the fundamental error is that In this case, the fundamental error is that
<tt>std:list::iterator</tt> does not model the concept of <a <tt>std:list::iterator</tt> does not model the concept of <a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a>. The list iterator is only bidirectional, not RandomAccessIterator</a>. The list iterator is only bidirectional, not
fully random access (as would be a vector iterator). Unfortunately, fully random access (as would be a vector iterator). Unfortunately,
there is nothing in the error message to indicate this to the user. there is nothing in the error message to indicate this to the user.
@@ -222,7 +222,7 @@ reasons why this message would be hard to understand.
<LI> There is no textual correlation between the error message and the <LI> There is no textual correlation between the error message and the
documented requirements for <tt>std::stable_sort()</tt> and for documented requirements for <tt>std::stable_sort()</tt> and for
<a <a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a>. RandomAccessIterator</a>.
<LI> The error message is overly long, listing functions internal <LI> The error message is overly long, listing functions internal
to the STL that the user does not (and should not!) know or care to the STL that the user does not (and should not!) know or care
@@ -256,7 +256,7 @@ error messages.
specified in the error message. specified in the error message.
<LI> The message refers explicitly to concepts that the user can look <LI> The message refers explicitly to concepts that the user can look
up in the STL documentation (<a up in the STL documentation (<a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a>). RandomAccessIterator</a>).
<LI> The error message is now much shorter and does not reveal <LI> The error message is now much shorter and does not reveal
internal STL functions. internal STL functions.

10
creating_concepts.htm
View File

@@ -24,7 +24,7 @@
As an example of how to create a concept checking class, we look As an example of how to create a concept checking class, we look
at how to create the corresponding checks for the at how to create the corresponding checks for the
<a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a> concept. First, as a convention we name the RandomAccessIterator</a> concept. First, as a convention we name the
concept checking class after the concept, and add the suffix concept checking class after the concept, and add the suffix
``<tt>Concept</tt>''. Next we must define a member function named ``<tt>Concept</tt>''. Next we must define a member function named
@@ -36,11 +36,11 @@ non-const member function with no parameters.
<p> <p>
The first part of the <tt>constraints()</tt> function includes The first part of the <tt>constraints()</tt> function includes
the requirements that correspond to the <i>refinement</i> relationship the requirements that correspond to the <i>refinement</i> relationship
between <a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> between <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a> and the concepts which it builds upon: RandomAccessIterator</a> and the concepts which it builds upon:
<a href="http://www.sgi.com/Technology/STL/BidirectionalIterator.html"> <a href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
BidirectionalIterator</a> and BidirectionalIterator</a> and
<a href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a>. We could have instead used LessThanComparable</a>. We could have instead used
<tt>BOOST_CLASS_REQUIRES</tt> and placed these requirements in the class <tt>BOOST_CLASS_REQUIRES</tt> and placed these requirements in the class
body, however <tt>BOOST_CLASS_REQUIRES</tt> uses C++ language features that body, however <tt>BOOST_CLASS_REQUIRES</tt> uses C++ language features that
@@ -51,7 +51,7 @@ Next we check that the <tt>iterator_category</tt> of the iterator is
either <tt>std::random_access_iterator_tag</tt> or a derived class. either <tt>std::random_access_iterator_tag</tt> or a derived class.
After that we write out some code that corresponds to the valid After that we write out some code that corresponds to the valid
expressions of the <a expressions of the <a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a> concept. Typedefs can also be added to RandomAccessIterator</a> concept. Typedefs can also be added to
enforce the associated types of the concept. enforce the associated types of the concept.

2
implementation.htm
View File

@@ -98,7 +98,7 @@ function named <tt>function_requires()</tt>. The following code
snippet shows how to use <tt>function_requires()</tt> to make sure snippet shows how to use <tt>function_requires()</tt> to make sure
that the iterator is a that the iterator is a
<a <a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a>. RandomAccessIterator</a>.
<pre> <pre>

14
prog_with_concepts.htm
View File

@@ -62,7 +62,7 @@ in the concept.
For example, the For example, the
<tt>std::stable_sort()</tt> function requires that the value type of <tt>std::stable_sort()</tt> function requires that the value type of
the iterator be <a the iterator be <a
href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a>, which not only LessThanComparable</a>, which not only
includes <tt>operator&lt;()</tt>, but also <tt>operator&gt;()</tt>, includes <tt>operator&lt;()</tt>, but also <tt>operator&gt;()</tt>,
<tt>operator&lt;=()</tt>, and <tt>operator&gt;=()</tt>. <tt>operator&lt;=()</tt>, and <tt>operator&gt;=()</tt>.
@@ -70,19 +70,19 @@ It turns out that <tt>std::stable_sort()</tt> only uses
<tt>operator&lt;()</tt>. The question then arises: should <tt>operator&lt;()</tt>. The question then arises: should
<tt>std::stable_sort()</tt> be specified in terms of the concept <tt>std::stable_sort()</tt> be specified in terms of the concept
<a <a
href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a> or in terms of a concept that only LessThanComparable</a> or in terms of a concept that only
requires <tt>operator&lt;()</tt>? requires <tt>operator&lt;()</tt>?
<p> <p>
We remark first that the use of <a We remark first that the use of <a
href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a> does not really violate the requirement LessThanComparable</a> does not really violate the requirement
minimization principle because all of the other operators can be minimization principle because all of the other operators can be
trivially implemented in terms of <tt>operator&lt;()</tt>. By trivially implemented in terms of <tt>operator&lt;()</tt>. By
``trivial'' we mean one line of code and a constant run-time cost. ``trivial'' we mean one line of code and a constant run-time cost.
More fundamentally, however, the use of <a More fundamentally, however, the use of <a
href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a> does not violate the requirement minimization LessThanComparable</a> does not violate the requirement minimization
principle because all of the comparison operators (<tt>&lt;</tt>, principle because all of the comparison operators (<tt>&lt;</tt>,
<tt>></tt>, <tt><=</tt>, <tt>>=</tt>) are conceptually equivalent (in <tt>></tt>, <tt><=</tt>, <tt>>=</tt>) are conceptually equivalent (in
@@ -100,7 +100,7 @@ implementation in places to use <tt>operator>()</tt> instead of
requirements are part of the public interface, such a change could requirements are part of the public interface, such a change could
potentially break client code. If instead potentially break client code. If instead
<a <a
href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a> is given as the requirement for LessThanComparable</a> is given as the requirement for
<tt>std::stable_sort()</tt>, then the maintainer is given a reasonable <tt>std::stable_sort()</tt>, then the maintainer is given a reasonable
amount of flexibility within which to work. amount of flexibility within which to work.
@@ -113,10 +113,10 @@ semantics of the problem domain being represented. In the problem
domain of basic containers, requiring traversal in a single direction domain of basic containers, requiring traversal in a single direction
is a smaller requirement than requiring traversal in both directions is a smaller requirement than requiring traversal in both directions
(hence the distinction between <a (hence the distinction between <a
href="http://www.sgi.com/Technology/STL/ForwardIterator.html"> href="http://www.sgi.com/tech/stl/ForwardIterator.html">
ForwardIterator</a> and ForwardIterator</a> and
<a <a
href="http://www.sgi.com/Technology/STL/BidirectionalIterator.html"> href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
BidirectionalIterator</a>). The semantic difference can be easily seen BidirectionalIterator</a>). The semantic difference can be easily seen
in the difference between the set of concrete data structures that in the difference between the set of concrete data structures that
have forward iterators versus the set that has bidirectional have forward iterators versus the set that has bidirectional

72
reference.htm
View File

@@ -72,54 +72,54 @@
struct <a href="../utility/Assignable.html">Assignable</a>Concept; // Standard ref 23.1 struct <a href="../utility/Assignable.html">Assignable</a>Concept; // Standard ref 23.1
template &lt;class T&gt; template &lt;class T&gt;
struct SGI<a href="http://www.sgi.com/Technology/STL/Assignable.html">Assignable</a>Concept; struct SGI<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>Concept;
template &lt;class T&gt; template &lt;class T&gt;
struct <a struct <a
href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</a>Concept; href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>Concept;
template &lt;class T&gt; template &lt;class T&gt;
struct <a href="../utility/CopyConstructible.html">CopyConstructible</a>Concept; // Standard ref 20.1.3 struct <a href="../utility/CopyConstructible.html">CopyConstructible</a>Concept; // Standard ref 20.1.3
template &lt;class T&gt; template &lt;class T&gt;
struct <a href="http://www.sgi.com/Technology/STL/EqualityComparable.html">EqualityComparable</a>Concept; // Standard ref 20.1.1 struct <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>Concept; // Standard ref 20.1.1
template &lt;class T&gt; template &lt;class T&gt;
struct <a href="../utility/LessThanComparable.html">LessThanComparable</a>Concept; // Standard ref 20.1.2 struct <a href="../utility/LessThanComparable.html">LessThanComparable</a>Concept; // Standard ref 20.1.2
template &lt;class T&gt; template &lt;class T&gt;
struct ComparableConcept; // The SGI STL <a href="http://www.sgi.com/Technology/STL/LessThanComparable.html">LessThanComparable</a> concept struct ComparableConcept; // The SGI STL <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</a> concept
</pre> </pre>
<h3><a name="iterator-concepts">Iterator Concept Checking Classes</a></h3> <h3><a name="iterator-concepts">Iterator Concept Checking Classes</a></h3>
<pre> <pre>
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct <a href="http://www.sgi.com/Technology/STL/trivial.html">TrivialIterator</a>Concept; struct <a href="http://www.sgi.com/tech/stl/trivial.html">TrivialIterator</a>Concept;
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct Mutable_TrivialIteratorConcept; struct Mutable_TrivialIteratorConcept;
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct <a href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>Concept; // Standard ref 24.1.1 Table 72 struct <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>Concept; // Standard ref 24.1.1 Table 72
template &lt;class Iter, class T&gt; template &lt;class Iter, class T&gt;
struct <a href="http://www.sgi.com/Technology/STL/OutputIterator.html">OutputIterator</a>Concept; // Standard ref 24.1.2 Table 73 struct <a href="http://www.sgi.com/tech/stl/OutputIterator.html">OutputIterator</a>Concept; // Standard ref 24.1.2 Table 73
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct <a href="http://www.sgi.com/Technology/STL/ForwardIterator.html">ForwardIterator</a>Concept; // Standard ref 24.1.3 Table 74 struct <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>Concept; // Standard ref 24.1.3 Table 74
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct Mutable_ForwardIteratorConcept; struct Mutable_ForwardIteratorConcept;
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct <a href="http://www.sgi.com/Technology/STL/BidirectionalIterator.html">BidirectionalIterator</a>Concept; // Standard ref 24.1.4 Table 75 struct <a href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>Concept; // Standard ref 24.1.4 Table 75
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct Mutable_BidirectionalIteratorConcept; struct Mutable_BidirectionalIteratorConcept;
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct <a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">RandomAccessIterator</a>Concept; // Standard ref 24.1.5 Table 76 struct <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>Concept; // Standard ref 24.1.5 Table 76
template &lt;class Iter&gt; template &lt;class Iter&gt;
struct Mutable_RandomAccessIteratorConcept; struct Mutable_RandomAccessIteratorConcept;
@@ -129,77 +129,93 @@
<pre> <pre>
template &lt;class Func, class Return&gt; template &lt;class Func, class Return&gt;
struct <a href="http://www.sgi.com/Technology/STL/Generator.html">Generator</a>Concept; struct <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a>Concept;
template &lt;class Func, class Return, class Arg&gt; template &lt;class Func, class Return, class Arg&gt;
struct <a href="http://www.sgi.com/Technology/STL/UnaryFunction.html">UnaryFunction</a>Concept; struct <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">UnaryFunction</a>Concept;
template &lt;class Func, class Return, class First, class Second&gt; template &lt;class Func, class Return, class First, class Second&gt;
struct <a href="http://www.sgi.com/Technology/STL/BinaryFunction.html">BinaryFunction</a>Concept; struct <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>Concept;
template &lt;class Func, class Arg&gt; template &lt;class Func, class Arg&gt;
struct Unary<a href="http://www.sgi.com/Technology/STL/Predicate.html">Predicate</a>Concept; struct Unary<a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>Concept;
template &lt;class Func, class First, class Second&gt; template &lt;class Func, class First, class Second&gt;
struct <a href="http://www.sgi.com/Technology/STL/BinaryPredicate.html">BinaryPredicate</a>Concept; struct <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>Concept;
template &lt;class Func, class First, class Second&gt; template &lt;class Func, class First, class Second&gt;
struct Const_BinaryPredicateConcept; struct Const_BinaryPredicateConcept;
template &lt;class Func, class Return&gt;
struct <a href="http://www.sgi.com/tech/stl/AdaptableGenerator.html">AdaptableGenerator</a>Concept;
template &lt;class Func, class Return, class Arg&gt;
struct <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>Concept;
template &lt;class Func, class First, class Second&gt;
struct <a href="http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html">AdaptableBinaryFunction</a>Concept;
template &lt;class Func, class Arg&gt;
struct <a href="http://www.sgi.com/tech/stl/AdaptablePredicate.html">AdaptablePredicate</a>Concept;
template &lt;class Func, class First, class Second&gt;
struct <a href="http://www.sgi.com/tech/stl/AdaptableBinaryPredicate.html">AdaptableBinaryPredicate</a>Concept;
</pre> </pre>
<h3><a name="container-concepts">Container Concept Checking Classes</a></h3> <h3><a name="container-concepts">Container Concept Checking Classes</a></h3>
<pre> <pre>
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/Container.html">Container</a>Concept; // Standard ref 23.1 Table 65 struct <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>Concept; // Standard ref 23.1 Table 65
template &lt;class C&gt; template &lt;class C&gt;
struct Mutable_ContainerConcept; struct Mutable_ContainerConcept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/ForwardContainer.html">ForwardContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/ForwardContainer.html">ForwardContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct Mutable_ForwardContainerConcept; struct Mutable_ForwardContainerConcept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/ReversibleContainer.html">ReversibleContainer</a>Concept; // Standard ref 23.1 Table 66 struct <a href="http://www.sgi.com/tech/stl/ReversibleContainer.html">ReversibleContainer</a>Concept; // Standard ref 23.1 Table 66
template &lt;class C&gt; template &lt;class C&gt;
struct Mutable_ReversibleContainerConcept; struct Mutable_ReversibleContainerConcept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/RandomAccessContainer.html">RandomAccessContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/RandomAccessContainer.html">RandomAccessContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct Mutable_RandomAccessContainerConcept; struct Mutable_RandomAccessContainerConcept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/SequenceContainer.html">Sequence</a>Concept; // Standard ref 23.1.1 struct <a href="http://www.sgi.com/tech/stl/SequenceContainer.html">Sequence</a>Concept; // Standard ref 23.1.1
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/FrontInsertionSequence.html">FrontInsertionSequence</a>Concept; struct <a href="http://www.sgi.com/tech/stl/FrontInsertionSequence.html">FrontInsertionSequence</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/BackInsertionSequence.html">BackInsertionSequence</a>Concept; struct <a href="http://www.sgi.com/tech/stl/BackInsertionSequence.html">BackInsertionSequence</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/Associative.html">AssociativeContainer</a>Concept; // Standard ref 23.1.2 Table 69 struct <a href="http://www.sgi.com/tech/stl/Associative.html">AssociativeContainer</a>Concept; // Standard ref 23.1.2 Table 69
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/UniqueAssociativeContainer.html">UniqueAssociativeContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html">UniqueAssociativeContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/MultipleAssociativeContainer.html">MultipleAssociativeContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/MultipleAssociativeContainer.html">MultipleAssociativeContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/SimpleAssociativeContainer.html">SimpleAssociativeContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/SimpleAssociativeContainer.html">SimpleAssociativeContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/PairAssociativeContainer.html">PairAssociativeContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/PairAssociativeContainer.html">PairAssociativeContainer</a>Concept;
template &lt;class C&gt; template &lt;class C&gt;
struct <a href="http://www.sgi.com/Technology/STL/SortedAssociativeContainer.html">SortedAssociativeContainer</a>Concept; struct <a href="http://www.sgi.com/tech/stl/SortedAssociativeContainer.html">SortedAssociativeContainer</a>Concept;
</pre> </pre>

8
using_concept_check.htm
View File

@@ -43,7 +43,7 @@ An example of a concept checking class from the BCCL is the
<tt>EqualityComparableConcept</tt> class. The class corresponds to the <tt>EqualityComparableConcept</tt> class. The class corresponds to the
EqualityComparable requirements described in 20.1.1 of the C++ EqualityComparable requirements described in 20.1.1 of the C++
Standard, and to the <a Standard, and to the <a
href="http://www.sgi.com/Technology/STL/EqualityComparable.html">EqualityComparable</a> href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
concept documented in the SGI STL. concept documented in the SGI STL.
<pre> <pre>
@@ -132,10 +132,10 @@ href="./concept_check.htm#motivating-example">motivating example</a>,
one good applicatino of concept checks would be to insert one good applicatino of concept checks would be to insert
<tt>function_requires()</tt> at the top of <tt>std::stable_sort()</tt> <tt>function_requires()</tt> at the top of <tt>std::stable_sort()</tt>
to make sure the template parameter type models <a to make sure the template parameter type models <a
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html"> href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
RandomAccessIterator</a>. In addition, <tt>std::stable_sort()</tt> RandomAccessIterator</a>. In addition, <tt>std::stable_sort()</tt>
requires that the <tt>value_type</tt> of the iterators be requires that the <tt>value_type</tt> of the iterators be
<a href="http://www.sgi.com/Technology/STL/LessThanComparable.html"> <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
LessThanComparable</a>, so we also use <tt>function_requires()</tt> to LessThanComparable</a>, so we also use <tt>function_requires()</tt> to
check this. check this.
@@ -182,7 +182,7 @@ type for the map.
As an example of using <tt>BOOST_CLASS_REQUIRES</tt> we look at a concept As an example of using <tt>BOOST_CLASS_REQUIRES</tt> we look at a concept
check that could be added to <tt>std::vector</tt>. One requirement check that could be added to <tt>std::vector</tt>. One requirement
that is placed on the element type is that it must be <a that is placed on the element type is that it must be <a
href="http://www.sgi.com/Technology/STL/Assignable.html">Assignable</a>. href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.
We can check this by inserting We can check this by inserting
<tt>class_requires&lt;AssignableConcept&lt;T&gt; &gt;</tt> at the top <tt>class_requires&lt;AssignableConcept&lt;T&gt; &gt;</tt> at the top
of the definition for <tt>std::vector</tt>. of the definition for <tt>std::vector</tt>.