Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r65741 - in sandbox/opaque/libs/opaque/doc: . html
From: vicente.botet_at_[hidden]
Date: 2010-10-03 15:56:15

Next message: garcia_at_[hidden]: "[Boost-commit] svn:boost r65742 - website/public_html/live/community"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65740 - in sandbox/opaque/boost/opaque: . meta_mixin"

Author: viboes
Date: 2010-10-03 15:56:13 EDT (Sun, 03 Oct 2010)
New Revision: 65741
URL: http://svn.boost.org/trac/boost/changeset/65741

Log:
Opaque:
* Added meta-mixins doc

Text files modified:
   sandbox/opaque/libs/opaque/doc/html/index.html | 1852 ++++++++++++++++++++++++++++++++++++---
   sandbox/opaque/libs/opaque/doc/opaque.qbk | 246 ++++
   2 files changed, 1904 insertions(+), 194 deletions(-)

Modified: sandbox/opaque/libs/opaque/doc/html/index.html
==============================================================================
--- sandbox/opaque/libs/opaque/doc/html/index.html (original)
+++ sandbox/opaque/libs/opaque/doc/html/index.html 2010-10-03 15:56:13 EDT (Sun, 03 Oct 2010)
@@ -177,7 +177,7 @@
 typedefs".
 

- In Alisdair Meredith show that the implicitly generating forwarding constructors
+ In Alisdair Meredith showed in [] the implicitly generating forwarding constructors
 to a base class new C++0x feature could not be useful to address this issue
 completly. Using this new feature it becomes possible to create something
 very like the required opaque typedef. For example:
@@ -187,8 +187,9 @@
};
</pre>

- This type is distrinct from std::string, functions can be overloaded on this
- type as well as std::string, yet std::string is not convertible to this type.
+ This type is distrinct from <code class="computeroutput">std::string</code>,
+ functions can be overloaded on this type as well as <code class="computeroutput">std::string</code>,
+ yet <code class="computeroutput">std::string</code> is not convertible to this type.
 

 As this proposals will not be part of the C++0x standard, a library solution
@@ -200,7 +201,8 @@
<a name="boost.opaque.overview.description"></a>Description
</h3></div></div></div>

- Boost.Opaque intends to provide a library partial solution to this problem.
+ Boost.Opaque intends to provide a library
+ partial solution to this problem.
 

 Boost.Opaque provides:
@@ -281,13 +283,13 @@
 Installing Boost.Opaque</a>
</h4></div></div></div>
<a name="boost.opaque.users_guide.getting_started.install.getting_boost_opaque"></a><h5>
-<a name="id4949072"></a>
+<a name="id4949134"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.getting_boost_opaque">Getting
 Boost.Opaque</a>
 </h5>

- You can get the last stable release of Boost.Opaque by downloading <code class="literal">ppaque.zip</code>
- from the <a href="http://www.boostpro.com/vault/index.php?action=downloadfile&filename=opaque.zip&directory=Utilities&" target="_top">Boost
+ You can get the last stable release of Boost.Opaque
+ by downloading <code class="literal">ppaque.zip</code> from the <a href="http://www.boostpro.com/vault/index.php?action=downloadfile&filename=opaque.zip&directory=Utilities&" target="_top">Boost
 Vault Utilities directory</a>
 

@@ -295,7 +297,7 @@
 Sandbox</a>.
 
<a name="boost.opaque.users_guide.getting_started.install.building_boost_opaque"></a><h5>
-<a name="id4949128"></a>
+<a name="id4949194"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.building_boost_opaque">Building
 Boost.Opaque</a>
 </h5>
@@ -305,7 +307,7 @@
 in your compiler include path.
 
<a name="boost.opaque.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4949160"></a>
+<a name="id4949227"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

@@ -313,7 +315,7 @@
 (and all libraries it depends on).
 
<a name="boost.opaque.users_guide.getting_started.install.exceptions_safety"></a><h5>
-<a name="id4949191"></a>
+<a name="id4949258"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.exceptions_safety">Exceptions
 safety</a>
 </h5>
@@ -322,7 +324,7 @@
 of exception safety as long as the underlying parameters provide it.
 
<a name="boost.opaque.users_guide.getting_started.install.thread_safety"></a><h5>
-<a name="id4949218"></a>
+<a name="id4949284"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.thread_safety">Thread
 safety</a>
 </h5>
@@ -330,7 +332,7 @@
 All functions in the library are thread-unsafe except when noted explicitly.
 
<a name="boost.opaque.users_guide.getting_started.install.tested_compilers"></a><h5>
-<a name="id4949243"></a>
+<a name="id4949310"></a>
 <a href="index.html#boost.opaque.users_guide.getting_started.install.tested_compilers">Tested
 compilers</a>
 </h5>
@@ -443,27 +445,29 @@
 
<div class="itemizedlist"><ul type="disc">
<li>
- the underlying type (int),
+ the underlying type (<code class="computeroutput">int</code>),
 </li>
<li>
- the unique tag of the new type (Identifier_tag),
+ the unique tag of the new type (<code class="computeroutput">Identifier_tag</code>),
 </li>
<li>
- a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+ a MPL sequence of additions (<code class="computeroutput">mpl::vector<opaque::using_totally_ordered1></code>)
 </li>
</ul></div>

- This will declare Identifier as new type different from int that provides
- just the operation associated to a totallyordered
+ This will declare Identifier as new type different from <code class="computeroutput">int</code>
+ that provides just the operation associated to a <code class="computeroutput">totally_ordered</code>
 concept. The concepts are represented by the library in the form a meta-mixin
- and are named with the using prefix, e.g. as using_totally_ordered1.
+ and are named with the <code class="computeroutput">using_</code>
+ prefix, e.g. as <code class="computeroutput">using_totally_ordered1</code>.
 

 We can now use Identifier as new int type, but limited to the totally ordered
 operations.
 

- Boost.Opaque provides a macros to simplify the preceding declaration
+ Boost.Opaque provides a macros to simplify
+ the preceding declaration
 
<pre class="programlisting">BOOST_OPAQUE_NEW_TYPE(int, Identifier, ((opaque::using_totally_ordered1)))
</pre>
@@ -493,23 +497,24 @@
};
</pre>

- In this case we use the mixin class new_class instead. The new_class class
- template has asthe following arguments,
+ In this case we use the mixin class <code class="computeroutput">new_class</code>
+ instead. The <code class="computeroutput">new_class</code>
+ class template has the following arguments,
 
<div class="itemizedlist"><ul type="disc">
<li>
 the class we are defining
 </li>
<li>
- the underlying type (int),
+ the underlying type (<code class="computeroutput">int</code>),
 </li>
<li>
- a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+ a MPL sequence of additions (<code class="computeroutput">mpl::vector<opaque::using_totally_ordered1></code>)
 </li>
</ul></div>

- Boost.Opaque provides a macros BOOST_OPAQUE_NEW_CLASS to simplify the preceding
- declaration
+ Boost.Opaque provides a macro <code class="computeroutput">BOOST_OPAQUE_NEW_CLASS</code> to simplify the
+ preceding declaration
 
<pre class="programlisting">BOOST_OPAQUE_NEW_CLASS(Identifier, int, ((opaque::using_totally_ordered1)))
{
@@ -518,7 +523,7 @@
}
</pre>

- The macros is responsable to define a uniqye tag and transform the preprocessor
+ The macros is responsable to define a unique tag and transform the preprocessor
 PPL sequence into a MPL sequence.
 
</div>
@@ -529,7 +534,8 @@
 type for relational operators: <code class="computeroutput">opaque::boolean</code></a>
</h4></div></div></div>

- The following code doesn't warms in (1) when we use 0 where a bool is expected.
+ The following code doesn't warns in (1) when we use <code class="computeroutput">0</code>
+ where a <code class="computeroutput">bool</code> is expected.
 
<pre class="programlisting">typedef bool Bool;
typedef int Int;
@@ -541,7 +547,8 @@
}
</pre>

- We can define an bool opaque typedef so only true_ and false_ are accepted
+ We can define an bool opaque typedef so only <code class="computeroutput">true_</code>
+ and <code class="computeroutput">false_</code> are accepted
 as constant expressions
 
<pre class="programlisting">typedef int Int;
@@ -554,7 +561,8 @@
}
</pre>

- Now we get an error on (1) as 0 is not convertible to opaque::boolean.
+ Now we get an error on (1) as <code class="computeroutput">0</code>
+ is not convertible to <code class="computeroutput">opaque::boolean</code>.
 This can be easily solved
 
<pre class="programlisting">Bool f(Int a, Int b)
@@ -564,14 +572,17 @@
}
</pre>

- But now we also get an error on (2) as a > b is not convertible to opaque::boolean.
- To solve this issue we need that the signature Int > Int be convertible
- to opaque::boolean.
+ But now we also get an error on (2) as <code class="computeroutput">a
+ > b</code>
+ is not convertible to <code class="computeroutput">opaque::boolean</code>.
+ To solve this issue we need that the signature <code class="computeroutput">Int
+ > Int</code>
+ be convertible to <code class="computeroutput">opaque::boolean</code>.
 

- Boost.Opaque provides a meta-mixin that allos to define an integer-like
- class that use opaque::boolean as type for the result of the relational
- operators.
+ Boost.Opaque provides a meta-mixin that
+ allos to define an integer-like class that use <code class="computeroutput">opaque::boolean</code>
+ as type for the result of the relational operators.
 
<pre class="programlisting">struct Int_tag;
typedef boost::opaque::new_type<int, Int_tag, boost::mpl::vector<
@@ -602,7 +613,8 @@
 

 For example, we can need real new typedefs to be able to overload a function.
- This can be done with the BOOST_OPAQUE_PUBLIC_TYPEDEF macro.
+ This can be done with the <code class="computeroutput">BOOST_OPAQUE_PUBLIC_TYPEDEF</code>
+ macro.
 
<pre class="programlisting">// Listing 1
// Cartesian 3D coordinate types
@@ -623,11 +635,12 @@
}; // PhysicsVector
</pre>

- BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X) creates a new type X with the same
- operations than double. The operations to forward are obtained from the
- traits class inherited_from_underlying<double>. The template class
- can be specialized for a particular type and the library already do that
- for all the built-in types.
+ <code class="computeroutput">BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X)</code>
+ creates a new type <code class="computeroutput">X</code> with
+ the same operations than <code class="computeroutput">double</code>.
+ The operations to forward are obtained from the traits class <code class="computeroutput">inherited_from_underlying<double></code>.
+ The template class can be specialized for a particular type and the library
+ already do that for all the built-in types.
 
</div>
<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
@@ -643,8 +656,8 @@
</h4></div></div></div>

 Sometimes we want to inherit most of the operations inherited from the
- underlying type. We can either use the new_type class and bee explicit
- on which operation we want
+ underlying type. We can either use the <code class="computeroutput">new_type</code>
+ class and bee explicit on which operation we want
 
<pre class="programlisting">BOOST_OPAQUE_NEW_TYPE(UT, NT, (
 (opaque::using_ope1)
@@ -706,6 +719,11 @@
<dd>
 Gimpel Software
 </dd>
+<dt><a href="http://www.drdobbs.com/184401633" target="_top">True
+ typedefs</a></dt>
+<dd>
+ Matthew Wilson
+ </dd>
</dl>
</div>
</div>
@@ -1319,8 +1337,8 @@
 Class Template <code class="computeroutput">linear_hierarchy<></code></a></dt></dl></dd>
<dt><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp">
 Header <code class="computeroutput"><boost/opaque/metamixin/inherited_from_undelying.hpp></code></a></dt>
-<dd><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.linear_hierarchy">
- Class Template <code class="computeroutput">linear_hierarchy<></code></a></dt></dl></dd>
+<dd><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.inherited_from_undelying">
+ Class Template <code class="computeroutput">inherited_from_undelying<></code></a></dt></dl></dd>
<dt><a href="index.html#boost.opaque.reference.meta_mixins.using_operators_hpp">
 Header <code class="computeroutput"><boost/opaque/metamixin/using_operators.hpp></code></a></dt>
<dd><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.using_operators_hpp.arithmetic_operators">Arithmetic
@@ -1522,8 +1540,8 @@
 Header <boost/opaque/metamixin/inherited_from_undelying.hpp>">
 Header <code class="computeroutput"><boost/opaque/metamixin/inherited_from_undelying.hpp></code></a>
</h4></div></div></div>
-<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.linear_hierarchy">
- Class Template <code class="computeroutput">linear_hierarchy<></code></a></dt></dl></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.inherited_from_undelying">
+ Class Template <code class="computeroutput">inherited_from_undelying<></code></a></dt></dl></div>
<pre class="programlisting">namespace boost {
 template <typename T, typename Bool=bool>
 struct inherited_from_undelying;
@@ -1531,9 +1549,9 @@
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.linear_hierarchy"></a><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.linear_hierarchy" title="
- Class Template linear_hierarchy<>">
- Class Template <code class="computeroutput">linear_hierarchy<></code></a>
+<a name="boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.inherited_from_undelying"></a><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp.inherited_from_undelying" title="
+ Class Template inherited_from_undelying<>">
+ Class Template <code class="computeroutput">inherited_from_undelying<></code></a>
</h5></div></div></div>
<pre class="programlisting">template <typename T, typename Bool>
struct inherited_from_undelying;
@@ -1576,7 +1594,7 @@
 for each one of the C++ overloadable operators.
 

- These metamixins have names that follows the naming used in Boost.ConceptsTraits,
+ These meta-mixins have names that follows the naming used in Boost.ConceptsTraits,
 but prefixed by <code class="computeroutput">using_</code>.
 
<div class="section" lang="en">
@@ -1607,110 +1625,1628 @@
 for the base class chaining technique.
 

- The primary operand type <code class="computeroutput">Final</code>
- needs to be of class type, built-in types are not supported.
- 
-</div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.opaque.reference.meta_mixins.hiding_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.hiding_operators_hpp" title="
- Header <boost/opaque/metamixin/hiding_operators.hpp>">
- Header <code class="computeroutput"><boost/opaque/metamixin/hiding_operators.hpp></code></a>
-</h4></div></div></div>
-
- This file includes metamixins that are used to hide operator overloads
- that have been defined by a base class for each one of the C++ overloadable
- operators.
- 
-
- These metamixins have names that follows the naming used in Boost.ConceptsTraits,
- but prefixed by <code class="computeroutput">hiding_</code>.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.opaque.reference.meta_mixins.using_combined_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.using_combined_operators_hpp" title="
- Header <boost/opaque/metamixin/using_combined_operators.hpp>">
- Header <code class="computeroutput"><boost/opaque/metamixin/using_combined_operators.hpp></code></a>
-</h4></div></div></div>
-
- This file includes metamixins combining several operators.
- 
-
- These metamixins have names that follows the naming used in Boost.Operators,
- but prefixed by <code class="computeroutput">using_</code>.
- 
-
- The composite operator templates only list what other templates they use.
- The supplied operations and requirements of the composite operator templates
- can be inferred from the operations and requirements of the listed components.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp" title="
- Header <boost/opaque/metamixin/hiding_combined_operators.hpp>">
- Header <code class="computeroutput"><boost/opaque/metamixin/hiding_combined_operators.hpp></code></a>
-</h4></div></div></div>
-
- This file includes metamixins combining several hiding operators.
- 
-
- This file includes metamixins combining several hiding metamixins that
- are used to hide operator overloads that have been defined by a base clas.
- 
-
- These metamixins have names that follows the naming used in Boost.Operators,
- but prefixed by <code class="computeroutput">hiding_</code>.
- 
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.opaque.reference.meta_mixins.transitive_substituable_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp" title="
- Header <boost/opaque/metamixin/transitive_substituable.hpp>">
- Header <code class="computeroutput"><boost/opaque/metamixin/transitive_substituable.hpp></code></a>
-</h4></div></div></div>
-<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable">
- Class Template <code class="computeroutput">transitive_substituable<></code></a></dt></dl></div>
-<pre class="programlisting">namespace boost {
- template <typename BaseClass, typename UT>
- struct transitive_substituable;
-}
-</pre>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h5 class="title">
-<a name="boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable" title="
- Class Template transitive_substituable<>">
- Class Template <code class="computeroutput">transitive_substituable<></code></a>
-</h5></div></div></div>
-
- This metamixin provides the Final class implicit conversions for all
- the underlying types hierarchy.
+ In the following table the meta-mixin follows the schema
 
-<pre class="programlisting">template <typename BaseClass, typename UT>
-struct transitive_substituable;
+<pre class="programlisting">struct meta-mixins {
+ template <typename NT, typename Base>
+ struct type: Base {
+ // Supplied Operation
+ };
+};
</pre>
-</div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp" title="
- Header <boost/opaque/metamixin/transitive_explicit_substituable.hpp>">
- Header <code class="computeroutput"><boost/opaque/metamixin/transitive_explicit_substituable.hpp></code></a>
-</h4></div></div></div>
-<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable">
- Class Template <code class="computeroutput">transitive_explicit_substituable<></code></a></dt></dl></div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h5 class="title">
-<a name="boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable" title="
- Class Template transitive_explicit_substituable<>">
- Class Template <code class="computeroutput">transitive_explicit_substituable<></code></a>
-</h5></div></div></div>
-<pre class="programlisting">namespace boost {
- template <typename BaseClass, typename UT>
- struct transitive_explicit_substituable;
-}
+<div class="itemizedlist"><ul type="disc">
+<li>
+ NT/NT2 is expected to satisfy the FinalUnderlying requirements.
+ </li>
+<li>
+ UT stands for NT::underlying_type
+ </li>
+<li>
+ UT2 stands for NT2::underlying_type
+ </li>
+<li>
+ this_ut is the instance UT reference obtained NT::underlying(this)
+ </li>
+<li>
+ lhs is a NT/NT2 const reference
+ </li>
+<li>
+ rhs is a NT/NT2 const reference
+ </li>
+<li>
+ lhs_ut is the instance UT reference obtained lhs.underlying()
+ </li>
+<li>
+ rhs_ut is the instance UT reference obtained rhs.underlying()
+ </li>
+</ul></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Meta-Mixin
+ 
+ </th>
+<th>
+ 
+ Supplied Operation
+ 
+ </th>
+<th>
+ 
+ Requirements
+ 
+ </th>
+<th>
+ 
+ Ref
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_underlying_conversion<UT></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">operator UT() const</code>
+ 
+ </td>
+<td>
+ 
+ None
+ 
+ </td>
+<td>
+ 
+ 12.3.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_conversion_to<T></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">operator T() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">T(ut)</code>
+ 
+ </td>
+<td>
+ 
+ 12.3.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_safe_bool_conversion</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">operator unspecified_bool_type() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">ut?true:false</code>
+ 
+ </td>
+<td>
+ 
+ 12.3.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_logical_not<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator!=() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(!this_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_unary_plus</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator+() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(+this_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_unary_minus</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator-() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(-this_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_not</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator~() const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(~this_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_pre_increment</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator++()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">++this_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_pre_decrement</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator--()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">--this_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_post_increment</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator++(int) const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut++</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_post_decrement</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator--(int) const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut++</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_less_than<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator<(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut <
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_less_than_equal<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator<=(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut <=
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_greater_than_equal<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator>=(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut >=
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_greater_than<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator>(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut >
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_equal<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator==(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut ==
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_not_equal<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool operator!=(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">Bool(this_ut !=
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_plus_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator+=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut +=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_minus_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator-=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut -=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_multiply_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator*=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut *=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_divide_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator/=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut /=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_modulus_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator%=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut %=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_xor_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator^=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut ^=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_and_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator&=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut &=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_or_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator|=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut |=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_left_right_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator<<=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut <<=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_right_shift_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator>>=(const NT& rhs)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">this_ut >>=
+ rhs_ut</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_plus</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator+(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut +
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_minus</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator-(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut -
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_multiply</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator*(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut *
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_divide</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator/(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut /
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_modulus</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator%(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut %
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_xor</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator^(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut ^
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_or</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator|(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut |
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_and</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator&(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut &
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_left_shift1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator<<(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut <<
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_right_shift1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT operator>>(const
+ NT&
+ rhs)
+ const</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(this_ut >>
+ rhs_ut)</code>
+ 
+ </td>
+<td>
+ 
+ 13.5.2
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.hiding_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.hiding_operators_hpp" title="
+ Header <boost/opaque/metamixin/hiding_operators.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_operators.hpp></code></a>
+</h4></div></div></div>
+
+ This file includes meta-mixins that are used to hide operator overloads
+ that have been defined by a base class for each one of the C++ overloadable
+ operators.
+ 
+
+ These meta-mixins have names that follows the naming used in Boost.ConceptsTraits,
+ but prefixed by <code class="computeroutput">hiding_</code>.
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Meta-Mixin
+ 
+ </th>
+<th>
+ 
+ Hidden Operation
+ 
+ </th>
+<th>
+ 
+ Requirements
+ 
+ </th>
+<th>
+ 
+ Ref
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">hiding_assign</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT&
+ operator=(NT const&)</code>
+ 
+ </td>
+<td>
+ 
+ None
+ 
+ </td>
+<td>
+ 
+ 13.5.3
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">hiding_copy</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">NT(NT const&)</code>
+ 
+ </td>
+<td>
+ 
+ None
+ 
+ </td>
+<td>
+ 
+ 13.5.3
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.using_combined_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.using_combined_operators_hpp" title="
+ Header <boost/opaque/metamixin/using_combined_operators.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/using_combined_operators.hpp></code></a>
+</h4></div></div></div>
+
+ This file includes meta-mixins combining several operators.
+ 
+
+ These meta-mixins have names that follows the naming used in Boost.Operators,
+ but prefixed by <code class="computeroutput">using_</code>.
+ 
+
+ The composite operator templates only list what other templates they use.
+ The supplied operations and requirements of the composite operator templates
+ can be inferred from the operations and requirements of the listed components.
+ 
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Meta-Mixin
+ 
+ </th>
+<th>
+ 
+ Meta-Mixin Sequence
+ 
+ </th>
+<th>
+ 
+ Ref
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_equality_comparable1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_equal<Bool></code>,
+ <code class="computeroutput">using_not_equal<Bool></code>
+ 
+ </td>
+<td>
+ 
+ 20.1.1
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_less_than_comparable1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_less_than<Bool></code> <code class="computeroutput">using_less_than_equal<Bool></code> <code class="computeroutput">using_greater_than_equal<Bool></code> <code class="computeroutput">using_greater_than<Bool></code>
+ 
+ </td>
+<td>
+ 
+ 20.1.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_partially_ordered1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_less_than<Bool></code> <code class="computeroutput">using_less_than_equal<Bool></code> <code class="computeroutput">using_greater_than_equal<Bool></code> <code class="computeroutput">using_greater_than<Bool></code>
+ 
+ </td>
+<td>
+ 
+ 20.1.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_addable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_plus_assign</code>
+ <code class="computeroutput">using_plus</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_subtractable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_minus_assign</code>
+ <code class="computeroutput">using_minus</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_multipliable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_multiply_assign</code>
+ <code class="computeroutput">using_multiply</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_dividable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_divide_assign</code>
+ <code class="computeroutput">using_divide</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_modable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_modulus_assign</code>
+ <code class="computeroutput">using_modulus</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_xorable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_xor_assign</code>
+ <code class="computeroutput">using_bitwise_xor</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_orable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_or_assign</code>
+ <code class="computeroutput">using_bitwise_or</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_andable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_and_assign</code>
+ <code class="computeroutput">using_bitwise_and</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_left_shiftable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_left_right_assign</code>
+ <code class="computeroutput">using_left_shift1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_right_shiftable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_right_shift_assign</code>
+ <code class="computeroutput">using_right_shift1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_incrementable</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_pre_increment></code> <code class="computeroutput">using_post_increment</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_decrementable</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_pre_decrement></code> <code class="computeroutput">using_post_decrement</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Meta-Mixin
+ 
+ </th>
+<th>
+ 
+ Meta-Mixin Sequence
+ 
+ </th>
+<th>
+ 
+ Ref
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_totally_ordered1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_equality_comparable1<Bool></code> <code class="computeroutput">using_less_than_comparable1<Bool></code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_additive1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_addable1</code>
+ <code class="computeroutput">using_subtractable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_multiplicative1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_multipliable1</code>
+ <code class="computeroutput">using_dividable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">integer_multiplicative1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_multiplicative1</code>
+ <code class="computeroutput">using_modable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_arithmetic1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_additive1</code>
+ <code class="computeroutput">using_multiplicative1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_integer_arithmetic1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_additive1</code>
+ <code class="computeroutput">integer_multiplicative1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_bitwise1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_bitwise_xorable1</code>
+ <code class="computeroutput">using_bitwise_orable1</code>
+ <code class="computeroutput">using_bitwise_andable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_unit_steppable</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_incrementable</code>
+ <code class="computeroutput">using_decrementable</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_shiftable1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_left_shiftable1</code>
+ <code class="computeroutput">using_right_shiftable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_ring_operators1</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_additive1</code>
+ <code class="computeroutput">using_multipliable1</code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_ordered_ring_operators1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_ring_operators1</code>
+ <code class="computeroutput">using_totally_ordered1<Bool></code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_field_operators1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_ring_operators1</code>
+ <code class="computeroutput">using_dividable1<Bool></code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">using_ordered_field_operators1<Bool></code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">using_field_operators1</code>
+ <code class="computeroutput">using_totally_ordered1<Bool></code>
+ 
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp" title="
+ Header <boost/opaque/metamixin/hiding_combined_operators.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_combined_operators.hpp></code></a>
+</h4></div></div></div>
+
+ This file includes meta-mixins combining several hiding meta-mixins that
+ are used to hide operator overloads that have been defined by a base clas.
+ 
+
+ These meta-mixins have names that follows the naming used in Boost.Operators,
+ but prefixed by <code class="computeroutput">hiding_</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.transitive_substituable_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp" title="
+ Header <boost/opaque/metamixin/transitive_substituable.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_substituable.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable">
+ Class Template <code class="computeroutput">transitive_substituable<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <typename BaseClass, typename UT>
+ struct transitive_substituable;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp.transitive_substituable" title="
+ Class Template transitive_substituable<>">
+ Class Template <code class="computeroutput">transitive_substituable<></code></a>
+</h5></div></div></div>
+
+ This metamixin provides the Final class implicit conversions for all
+ the underlying types hierarchy.
+ 
+<pre class="programlisting">template <typename BaseClass, typename UT>
+struct transitive_substituable;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp" title="
+ Header <boost/opaque/metamixin/transitive_explicit_substituable.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_explicit_substituable.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable">
+ Class Template <code class="computeroutput">transitive_explicit_substituable<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <typename BaseClass, typename UT>
+ struct transitive_explicit_substituable;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable"></a><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp.transitive_explicit_substituable" title="
+ Class Template transitive_explicit_substituable<>">
+ Class Template <code class="computeroutput">transitive_explicit_substituable<></code></a>
+</h5></div></div></div>
+<pre class="programlisting">template <typename BaseClass, typename UT>
+struct transitive_explicit_substituable;
</pre>

 This metamixin provides the Final class explicit conversions for all
@@ -1769,7 +3305,7 @@
 Rationale</a>
</h3></div></div></div>
<a name="boost.opaque.appendices.rationale.lala"></a><h4>
-<a name="id5005312"></a>
+<a name="id5012523"></a>
 <a href="index.html#boost.opaque.appendices.rationale.lala">lala</a>
 </h4>
</div>
@@ -1780,7 +3316,7 @@
 Implementation Notes</a>
</h3></div></div></div>
<a name="boost.opaque.appendices.implementation.lala"></a><h4>
-<a name="id5005345"></a>
+<a name="id5012561"></a>
 <a href="index.html#boost.opaque.appendices.implementation.lala">lala</a>
 </h4>
</div>
@@ -1881,7 +3417,7 @@
<a name="boost.opaque.appendices.todo"></a> Appendix F: Future plans
</h3></div></div></div>
<a name="boost.opaque.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id5005548"></a>
+<a name="id5012781"></a>
 <a href="index.html#boost.opaque.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h4>
@@ -1889,7 +3425,7 @@
 lala
 </li></ul></div>
<a name="boost.opaque.appendices.todo.for_later_releases"></a><h4>
-<a name="id5005578"></a>
+<a name="id5012814"></a>
 <a href="index.html#boost.opaque.appendices.todo.for_later_releases">For later
 releases</a>
 </h4>
@@ -1900,7 +3436,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: October 02, 2010 at 22:43:11 GMT</td>
+<td align="left">Last revised: October 03, 2010 at 19:53:00 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/opaque/libs/opaque/doc/opaque.qbk
==============================================================================
--- sandbox/opaque/libs/opaque/doc/opaque.qbk (original)
+++ sandbox/opaque/libs/opaque/doc/opaque.qbk 2010-10-03 15:56:13 EDT (Sun, 03 Oct 2010)
@@ -102,13 +102,13 @@
# Application of inheritance makes no provision that permits a base class to be cv-qualified.
]

-In Alisdair Meredith show that the implicitly generating forwarding constructors to a base class new C++0x feature could not be useful to address this issue completly. Using this new feature it becomes possible to create something very like the required opaque typedef. For example:
+In Alisdair Meredith showed in [] the implicitly generating forwarding constructors to a base class new C++0x feature could not be useful to address this issue completly. Using this new feature it becomes possible to create something very like the required opaque typedef. For example:

 struct MyType : std::string {
 using string::string;
 };

-This type is distrinct from std::string, functions can be overloaded on this type as well as std::string, yet std::string is not convertible to this type.
+This type is distrinct from `std::string`, functions can be overloaded on this type as well as `std::string`, yet `std::string` is not convertible to this type.

As this proposals will not be part of the C++0x standard, a library solution that could satisfy most of the requirements seems a loable approach.

@@ -119,7 +119,7 @@
[/==================]

-Boost.Opaque intends to provide a library partial solution to this problem.
+[*Boost.Opaque] intends to provide a library partial solution to this problem.

[*Boost.Opaque] provides:

@@ -148,7 +148,7 @@
[heading Getting Boost.Opaque]
[/=================================]

-You can get the last stable release of Boost.Opaque by downloading [^ppaque.zip] from the
+You can get the last stable release of [*Boost.Opaque] by downloading [^ppaque.zip] from the
[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=opaque.zip&directory=Utilities& Boost Vault Utilities directory]

You can also access the latest (unstable?) state from the [@https://svn.boost.org/svn/boost/sandbox/opaque Boost Sandbox].
@@ -240,15 +240,15 @@

New we use the opaque new_type class which has as parameters:

-* the underlying type (int),
-* the unique tag of the new type (Identifier_tag),
-* a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+* the underlying type (`int`),
+* the unique tag of the new type (`Identifier_tag`),
+* a MPL sequence of additions (`mpl::vector<opaque::using_totally_ordered1>`)

-This will declare Identifier as new type different from int that provides just the operation associated to a totally_ordered concept. The concepts are represented by the library in the form a meta-mixin and are named with the using_ prefix, e.g. as using_totally_ordered1.
+This will declare Identifier as new type different from `int` that provides just the operation associated to a `totally_ordered` concept. The concepts are represented by the library in the form a meta-mixin and are named with the `using_` prefix, e.g. as `using_totally_ordered1`.

We can now use Identifier as new int type, but limited to the totally ordered operations.

-Boost.Opaque provides a macros to simplify the preceding declaration
+[*Boost.Opaque] provides a macros to simplify the preceding declaration

 BOOST_OPAQUE_NEW_TYPE(int, Identifier, ((opaque::using_totally_ordered1)))

@@ -269,13 +269,13 @@
 // ...
 };

-In this case we use the mixin class new_class instead. The new_class class template has asthe following arguments,
+In this case we use the mixin class `new_class` instead. The `new_class` class template has the following arguments,

* the class we are defining
-* the underlying type (int),
-* a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+* the underlying type (`int`),
+* a MPL sequence of additions (`mpl::vector<opaque::using_totally_ordered1>`)

-Boost.Opaque provides a macros BOOST_OPAQUE_NEW_CLASS to simplify the preceding declaration
+[*Boost.Opaque] provides a macro `BOOST_OPAQUE_NEW_CLASS` to simplify the preceding declaration

 BOOST_OPAQUE_NEW_CLASS(Identifier, int, ((opaque::using_totally_ordered1)))
 {
@@ -283,13 +283,13 @@
 // ...
 }

-The macros is responsable to define a uniqye tag and transform the preprocessor PPL sequence into a MPL sequence.
+The macros is responsable to define a unique tag and transform the preprocessor PPL sequence into a MPL sequence.

[endsect]

[section Return type for relational operators: `opaque::boolean`]

-The following code doesn't warms in (1) when we use 0 where a bool is expected.
+The following code doesn't warns in (1) when we use `0` where a `bool` is expected.

 typedef bool Bool;
 typedef int Int;
@@ -300,7 +300,7 @@
 else return a > b;
 }

-We can define an bool opaque typedef so only true_ and false_ are accepted as constant expressions
+We can define an bool opaque typedef so only `true_` and `false_` are accepted as constant expressions

 typedef int Int;
 typedef opaque::boolean Bool;
@@ -311,7 +311,7 @@
 else return a > b; // (2) Error
 }

-Now we get an error on (1) as 0 is not convertible to opaque::boolean. This can be easily solved
+Now we get an error on (1) as `0` is not convertible to `opaque::boolean`. This can be easily solved

 Bool f(Int a, Int b)
 {
@@ -319,9 +319,9 @@
 else return a > b; // (2) Error
 }

-But now we also get an error on (2) as a > b is not convertible to opaque::boolean. To solve this issue we need that the signature Int > Int be convertible to opaque::boolean.
+But now we also get an error on (2) as `a > b` is not convertible to `opaque::boolean`. To solve this issue we need that the signature `Int > Int` be convertible to `opaque::boolean`.

-Boost.Opaque provides a meta-mixin that allos to define an integer-like class that use opaque::boolean as type for the result of the relational operators.
+[*Boost.Opaque] provides a meta-mixin that allos to define an integer-like class that use `opaque::boolean` as type for the result of the relational operators.

 struct Int_tag;
 typedef boost::opaque::new_type<int, Int_tag, boost::mpl::vector<
@@ -341,7 +341,7 @@

While the preceding examples restrict the operations of the underlying type, sometimes it is useful to define a different type that provides the same operations than the underlying type and that allows some conversions. In this case we use the opaque typedefs.

-For example, we can need real new typedefs to be able to overload a function. This can be done with the BOOST_OPAQUE_PUBLIC_TYPEDEF macro.
+For example, we can need real new typedefs to be able to overload a function. This can be done with the `BOOST_OPAQUE_PUBLIC_TYPEDEF` macro.

 // Listing 1
 // Cartesian 3D coordinate types
@@ -361,7 +361,7 @@
 ...
 }; // PhysicsVector

-BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X) creates a new type X with the same operations than double. The operations to forward are obtained from the traits class inherited_from_underlying<double>. The template class can be specialized for a particular type and the library already do that for all the built-in types.
+`BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X)` creates a new type `X` with the same operations than `double`. The operations to forward are obtained from the traits class `inherited_from_underlying<double>`. The template class can be specialized for a particular type and the library already do that for all the built-in types.

[endsect]

@@ -371,7 +371,7 @@

[section Hiding inherited operations]

-Sometimes we want to inherit most of the operations inherited from the underlying type. We can either use the new_type class and bee explicit on which operation we want
+Sometimes we want to inherit most of the operations inherited from the underlying type. We can either use the `new_type` class and bee explicit on which operation we want

 BOOST_OPAQUE_NEW_TYPE(UT, NT, (
 (opaque::using_ope1)
@@ -431,6 +431,12 @@
 [Gimpel Software]
]

+[
+ [[@http://www.drdobbs.com/184401633 [*True typedefs]]]
+ [Matthew Wilson]
+]
+
+
]

[endsect]
@@ -991,13 +997,13 @@
 }

[/==========================================================================================]
-[section:linear_hierarchy Class Template `linear_hierarchy<>`]
+[section:inherited_from_undelying Class Template `inherited_from_undelying<>`]
[/==========================================================================================]

 template <typename T, typename Bool>
 struct inherited_from_undelying;

-`inherited_from_undelying` is a `MetaMixin` which add wrapping member to the underlyibg type `UT`.
+`inherited_from_undelying` is a `MetaMixin` which adds wrapping member to the underlyibg type `UT`.

This class must specialized for specific types in order to make easier the construction of opaque types having `UT` as underlying type. For example the library provide specializations for each one of the buil-in types.

@@ -1016,7 +1022,7 @@

This file includes meta-mixins that are used to add un operator overloads forwarding from the Final type to the underlying type. There is a meta-mixins for each one of the C++ overloadable operators.

-These metamixins have names that follows the naming used in Boost.ConceptsTraits, but prefixed by `using_`.
+These meta-mixins have names that follows the naming used in Boost.ConceptsTraits, but prefixed by `using_`.

[section Arithmetic Operators]
@@ -1028,7 +1034,72 @@

These meta-mixins are "simple" since they provide un operator based on a single operation the underlying type has to provide. They have an additional optional template parameter Base, which is not shown, for the base class chaining technique.

-The primary operand type `Final` needs to be of class type, built-in types are not supported.
+In the following table the meta-mixin follows the schema
+
+ struct meta-mixins {
+ template <typename NT, typename Base>
+ struct type: Base {
+ // Supplied Operation
+ };
+ };
+
+* NT/NT2 is expected to satisfy the FinalUnderlying requirements.
+* UT stands for NT::underlying_type
+* UT2 stands for NT2::underlying_type
+* this_ut is the instance UT reference obtained NT::underlying(this)
+* lhs is a NT/NT2 const reference
+* rhs is a NT/NT2 const reference
+* lhs_ut is the instance UT reference obtained lhs.underlying()
+* rhs_ut is the instance UT reference obtained rhs.underlying()
+
+[table
+ [[Meta-Mixin] [Supplied Operation] [Requirements] [Ref]]
+ [[`using_underlying_conversion<UT>`][`operator UT() const`][None][12.3.2]]
+ [[`using_conversion_to<T>`][`operator T() const`][`T(ut)`][12.3.2]]
+ [[`using_safe_bool_conversion`][`operator unspecified_bool_type() const`][`ut?true:false`][12.3.2]]
+
+ [[`using_logical_not<Bool>`][`Bool operator!=() const`][`Bool(!this_ut)`][13.5.1]]
+ [[`using_unary_plus`][`NT operator+() const`][`NT(+this_ut)`][13.5.1]]
+ [[`using_unary_minus`][`NT operator-() const`][`NT(-this_ut)`][13.5.1]]
+ [[`using_bitwise_not`][`NT operator~() const`][`NT(~this_ut)`][13.5.1]]
+
+ [[`using_pre_increment`][`NT& operator++()`][`++this_ut`][13.5.1]]
+ [[`using_pre_decrement`][`NT& operator--()`][`--this_ut`][13.5.1]]
+ [[`using_post_increment`][`NT operator++(int) const`][`this_ut++`][13.5.1]]
+ [[`using_post_decrement`][`NT operator--(int) const`][`this_ut++`][13.5.1]]
+
+ [[`using_less_than<Bool>`][`Bool operator<(const NT& rhs) const`][`Bool(this_ut < rhs_ut)`][13.5.2]]
+ [[`using_less_than_equal<Bool>`][`Bool operator<=(const NT& rhs) const`][`Bool(this_ut <= rhs_ut)`][13.5.2]]
+ [[`using_greater_than_equal<Bool>`][`Bool operator>=(const NT& rhs) const`][`Bool(this_ut >= rhs_ut)`][13.5.2]]
+ [[`using_greater_than<Bool>`][`Bool operator>(const NT& rhs) const`][`Bool(this_ut > rhs_ut)`][13.5.2] ]
+ [[`using_equal<Bool>`][`Bool operator==(const NT& rhs) const`][`Bool(this_ut == rhs_ut)`][13.5.2] ]
+ [[`using_not_equal<Bool>`][`Bool operator!=(const NT& rhs) const`][`Bool(this_ut != rhs_ut)`][13.5.2] ]
+
+
+ [[`using_plus_assign`][`NT& operator+=(const NT& rhs)`][`this_ut += rhs_ut`][13.5.2]]
+ [[`using_minus_assign`][`NT& operator-=(const NT& rhs)`][`this_ut -= rhs_ut`][13.5.2]]
+ [[`using_multiply_assign`][`NT& operator*=(const NT& rhs)`][`this_ut *= rhs_ut`][13.5.2]]
+ [[`using_divide_assign`][`NT& operator/=(const NT& rhs)`][`this_ut /= rhs_ut`][13.5.2]]
+ [[`using_modulus_assign`][`NT& operator%=(const NT& rhs)`][`this_ut %= rhs_ut`][13.5.2]]
+ [[`using_bitwise_xor_assign`][`NT& operator^=(const NT& rhs)`][`this_ut ^= rhs_ut`][13.5.2]]
+ [[`using_bitwise_and_assign`][`NT& operator&=(const NT& rhs)`][`this_ut &= rhs_ut`][13.5.2]]
+ [[`using_bitwise_or_assign`][`NT& operator|=(const NT& rhs)`][`this_ut |= rhs_ut`][13.5.2]]
+ [[`using_left_right_assign`][`NT& operator<<=(const NT& rhs)`][`this_ut <<= rhs_ut`][13.5.2]]
+ [[`using_right_shift_assign`][`NT& operator>>=(const NT& rhs)`][`this_ut >>= rhs_ut`][13.5.2]]
+
+
+ [[`using_plus`][`NT operator+(const NT& rhs) const`][`NT(this_ut + rhs_ut)`][13.5.2]]
+ [[`using_minus`][`NT operator-(const NT& rhs) const`][`NT(this_ut - rhs_ut)`][13.5.2]]
+ [[`using_multiply`][`NT operator*(const NT& rhs) const`][`NT(this_ut * rhs_ut)`][13.5.2]]
+ [[`using_divide`][`NT operator/(const NT& rhs) const`][`NT(this_ut / rhs_ut)`][13.5.2]]
+ [[`using_modulus`][`NT operator%(const NT& rhs) const`][`NT(this_ut % rhs_ut)`][13.5.2]]
+ [[`using_bitwise_xor`][`NT operator^(const NT& rhs) const`][`NT(this_ut ^ rhs_ut)`][13.5.2]]
+ [[`using_bitwise_or`][`NT operator|(const NT& rhs) const`][`NT(this_ut | rhs_ut)`][13.5.2]]
+ [[`using_bitwise_and`][`NT operator&(const NT& rhs) const`][`NT(this_ut & rhs_ut)`][13.5.2]]
+ [[`using_left_shift1`][`NT operator<<(const NT& rhs) const`][`NT(this_ut << rhs_ut)`][13.5.2]]
+ [[`using_right_shift1`][`NT operator>>(const NT& rhs) const`][`NT(this_ut >> rhs_ut)`][13.5.2]]
+
+]

[endsect]
[endsect]
@@ -1037,9 +1108,15 @@
[section:hiding_operators_hpp Header `<boost/opaque/metamixin/hiding_operators.hpp>`]
[/==========================================================================================]

-This file includes metamixins that are used to hide operator overloads that have been defined by a base class for each one of the C++ overloadable operators.
+This file includes meta-mixins that are used to hide operator overloads that have been defined by a base class for each one of the C++ overloadable operators.
+
+These meta-mixins have names that follows the naming used in Boost.ConceptsTraits, but prefixed by `hiding_`.

-These metamixins have names that follows the naming used in Boost.ConceptsTraits, but prefixed by `hiding_`.
+[table
+ [[Meta-Mixin] [Hidden Operation] [Requirements] [Ref]]
+ [[`hiding_assign`][`NT& operator=(NT const&)`][None][13.5.3]]
+ [[`hiding_copy`][`NT(NT const&)`][None][13.5.3]]
+]

[endsect]

@@ -1047,23 +1124,117 @@
[section:using_combined_operators_hpp Header `<boost/opaque/metamixin/using_combined_operators.hpp>`]
[/==========================================================================================]

-This file includes metamixins combining several operators.
+This file includes meta-mixins combining several operators.

-These metamixins have names that follows the naming used in Boost.Operators, but prefixed by `using_`.
+These meta-mixins have names that follows the naming used in Boost.Operators, but prefixed by `using_`.

The composite operator templates only list what other templates they use. The supplied operations and requirements of the composite operator templates can be inferred from the operations and requirements of the listed components.

+[table
+ [[Meta-Mixin] [Meta-Mixin Sequence] [Ref]]
+ [[`using_equality_comparable1<Bool>`][`using_equal<Bool>`,
+ \n `using_not_equal<Bool>`
+ ][20.1.1]]
+ [[`using_less_than_comparable1<Bool>`][`using_less_than<Bool>`
+ \n `using_less_than_equal<Bool>`
+ \n `using_greater_than_equal<Bool>`
+ \n `using_greater_than<Bool>`
+ ][20.1.2]]
+ [[`using_partially_ordered1<Bool>`][`using_less_than<Bool>`
+ \n `using_less_than_equal<Bool>`
+ \n `using_greater_than_equal<Bool>`
+ \n `using_greater_than<Bool>`
+ ][20.1.2]]
+ [[`using_addable1`][`using_plus_assign`
+ \n `using_plus`
+ ][]]
+ [[`using_subtractable1`][`using_minus_assign`
+ \n `using_minus`
+ ][]]
+ [[`using_multipliable1`][`using_multiply_assign`
+ \n `using_multiply`
+ ][]]
+ [[`using_dividable1`][`using_divide_assign`
+ \n `using_divide`
+ ][]]
+ [[`using_modable1`][`using_modulus_assign`
+ \n `using_modulus`
+ ][]]
+ [[`using_bitwise_xorable1`][`using_bitwise_xor_assign`
+ \n `using_bitwise_xor`
+ ][]]
+ [[`using_bitwise_orable1`][`using_bitwise_or_assign`
+ \n `using_bitwise_or`
+ ][]]
+ [[`using_bitwise_andable1`][`using_bitwise_and_assign`
+ \n `using_bitwise_and`
+ ][]]
+ [[`using_left_shiftable1`][`using_left_right_assign`
+ \n `using_left_shift1`
+ ][]]
+ [[`using_right_shiftable1`][`using_right_shift_assign`
+ \n `using_right_shift1`
+ ][]]
+ [[`using_incrementable`][`using_pre_increment>`
+ \n `using_post_increment`
+ ][]]
+ [[`using_decrementable`][`using_pre_decrement>`
+ \n `using_post_decrement`
+ ][]]
+]
+
+[table
+ [[Meta-Mixin] [Meta-Mixin Sequence] [Ref]]
+ [[`using_totally_ordered1<Bool>`][`using_equality_comparable1<Bool>`
+ \n `using_less_than_comparable1<Bool>`
+ ][]]
+ [[`using_additive1`][`using_addable1`
+ \n `using_subtractable1`
+ ][]]
+ [[`using_multiplicative1`][`using_multipliable1`
+ \n `using_dividable1`
+ ][]]
+ [[`integer_multiplicative1`][`using_multiplicative1`
+ \n `using_modable1`
+ ][]]
+ [[`using_arithmetic1`][`using_additive1`
+ \n `using_multiplicative1`
+ ][]]
+ [[`using_integer_arithmetic1`][`using_additive1`
+ \n `integer_multiplicative1`
+ ][]]
+ [[`using_bitwise1`][`using_bitwise_xorable1`
+ \n `using_bitwise_orable1`
+ \n `using_bitwise_andable1`
+ ][]]
+ [[`using_unit_steppable`][`using_incrementable`
+ \n `using_decrementable`
+ ][]]
+ [[`using_shiftable1`][`using_left_shiftable1`
+ \n `using_right_shiftable1`
+ ][]]
+ [[`using_ring_operators1`][`using_additive1`
+ \n `using_multipliable1`
+ ][]]
+ [[`using_ordered_ring_operators1<Bool>`][`using_ring_operators1`
+ \n `using_totally_ordered1<Bool>`
+ ][]]
+ [[`using_field_operators1<Bool>`][`using_ring_operators1`
+ \n `using_dividable1<Bool>`
+ ][]]
+ [[`using_ordered_field_operators1<Bool>`][`using_field_operators1`
+ \n `using_totally_ordered1<Bool>`
+ ][]]
+]

[endsect]
[/==========================================================================================]
[section:hiding_combined_operators_hpp Header `<boost/opaque/metamixin/hiding_combined_operators.hpp>`]
[/==========================================================================================]

-This file includes metamixins combining several hiding operators.
-
-This file includes metamixins combining several hiding metamixins that are used to hide operator overloads that have been defined by a base clas.
+This file includes meta-mixins combining several hiding meta-mixins that are used to hide operator overloads that have been defined by a base clas.

-These metamixins have names that follows the naming used in Boost.Operators, but prefixed by `hiding_`.
+These meta-mixins have names that follows the naming used in Boost.Operators, but prefixed by `hiding_`.

[endsect]

@@ -1093,14 +1264,17 @@
[section:transitive_explicit_substituable_hpp Header `<boost/opaque/metamixin/transitive_explicit_substituable.hpp>`]
[/==========================================================================================]

+ namespace boost {
+ template <typename BaseClass, typename UT>
+ struct transitive_explicit_substituable;
+ }
+
[/==========================================================================================]
[section:transitive_explicit_substituable Class Template `transitive_explicit_substituable<>`]
[/==========================================================================================]

- namespace boost {
 template <typename BaseClass, typename UT>
 struct transitive_explicit_substituable;
- }

This metamixin provides the Final class explicit conversions for all the underlying types hierarchy (when the compiler supports explicit conversion operators). For portability purposed the library provide as workarround a convert_to non member function.

Next message: garcia_at_[hidden]: "[Boost-commit] svn:boost r65742 - website/public_html/live/community"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65740 - in sandbox/opaque/boost/opaque: . meta_mixin"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk