Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r65731 - in sandbox/opaque/libs/opaque/doc: . html
From: vicente.botet_at_[hidden]
Date: 2010-10-02 18:44:58

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65732 - in sandbox/opaque/boost/opaque: . meta_mixin"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65730 - in sandbox/opaque/libs/opaque: example test"

Author: viboes
Date: 2010-10-02 18:44:55 EDT (Sat, 02 Oct 2010)
New Revision: 65731
URL: http://svn.boost.org/trac/boost/changeset/65731

Log:
Opaque:
* Add first draft of the documentation

Added:
   sandbox/opaque/libs/opaque/doc/html/
   sandbox/opaque/libs/opaque/doc/html/index.html (contents, props changed)
   sandbox/opaque/libs/opaque/doc/html/standalone_HTML.manifest (contents, props changed)
Text files modified:
   sandbox/opaque/libs/opaque/doc/Jamfile.v2 | 2
   sandbox/opaque/libs/opaque/doc/opaque.qbk | 958 ++++++++++++++++++++++++++++++++++++++-
   2 files changed, 918 insertions(+), 42 deletions(-)

Modified: sandbox/opaque/libs/opaque/doc/Jamfile.v2
==============================================================================
--- sandbox/opaque/libs/opaque/doc/Jamfile.v2 (original)
+++ sandbox/opaque/libs/opaque/doc/Jamfile.v2 2010-10-02 18:44:55 EDT (Sat, 02 Oct 2010)
@@ -33,7 +33,7 @@
 # Use graphics not text for navigation:
 <xsl:param>navig.graphics=1
 # How far down we chunk nested sections, basically all of them:
- <xsl:param>chunk.section.depth=2
+ <xsl:param>chunk.section.depth=0
 # Don't put the first section on the same page as the TOC:
 <xsl:param>chunk.first.sections=1
 # How far down sections get TOC's

Added: sandbox/opaque/libs/opaque/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/opaque/libs/opaque/doc/html/index.html 2010-10-02 18:44:55 EDT (Sat, 02 Oct 2010)
@@ -0,0 +1,1909 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Toward Boost.Opaque 0.1.0</title>
+<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="index.html" title="Toward Boost.Opaque 0.1.0">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+<div class="article" lang="en">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="boost.opaque"></a>Toward Boost.Opaque 0.1.0</h2></div>
+<div><div class="authorgroup"><div class="author"><h3 class="author">
+Vicente J. Botet Escriba
+</h3></div></div></div>
+<div>Copyright © 2010 Vicente J. Botet Escriba</div>
+<div><div class="legalnotice">
+<a name="id4987066"></a>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+Table of Contents
+<dl>
+<dt>Overview</dt>
+<dd><dl>
+<dt>Motivation</dt>
+<dt>Description</dt>
+</dl></dd>
+<dt> Users' Guide</dt>
+<dd><dl>
+<dt> Getting Started</dt>
+<dt>Tutorial</dt>
+<dt>Examples</dt>
+<dt> External Resources</dt>
+</dl></dd>
+<dt>Reference</dt>
+<dd><dl>
+<dt> Header <boost/opaque.hpp></dt>
+<dt> Header <boost/opaque/new_class.hpp></dt>
+<dt> Header <boost/opaque/new_type.hpp></dt>
+<dt> Header <boost/opaque/boolean.hpp></dt>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_class.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_type_hpp"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_type.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_class.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_type_hpp"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_type.hpp></code></a></dt>
+<dt> Header <boost/opaque/macros.hpp></dt>
+<dt>Meta-Mixins</dt>
+</dl></dd>
+<dt>Appendices</dt>
+<dd><dl>
+<dt> Appendix A: History</dt>
+<dt><a href="index.html#boost.opaque.appendices.rationale"> Appendix B: Design
+ Rationale</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.implementation"> Appendix C:
+ Implementation Notes</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.acknowledgements"> Appendix D:
+ Acknowledgements</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.appendix_e__tests">Appendix E:
+ Tests</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.appendix_f__tickets">Appendix
+ F: Tickets</a></dt>
+<dt> Appendix F: Future plans</dt>
+</dl></dd>
+</dl>
+</div>
+<div class="blockquote"><blockquote class="blockquote">
+ “Strong type checking is gold; normal type checking is silver; and casting
+ is brass”
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ -- 
+ </blockquote></div>
+<div class="warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../doc/src/images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top">
+ Opaque is not a part of the Boost libraries.
+ </td></tr>
+</table></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.opaque.overview"></a>Overview
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt>Motivation</dt>
+<dt>Description</dt>
+</dl></div>
+<a name="boost.opaque.overview.how_to_use_this_documentation"></a><h3>
+<a name="id4948562"></a>
+ <a href="index.html#boost.opaque.overview.how_to_use_this_documentation">How to
+ Use This Documentation</a>
+ </h3>
+
+ This documentation makes use of the following naming and formatting conventions.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Code is in <code class="computeroutput">fixed width
+ font</code> and is syntax-highlighted.
+ </li>
+<li>
+ Replaceable text that you will need to supply is in <code>italics</code>.
+ </li>
+<li>
+ If a name refers to a free function, it is specified like this: <code class="computeroutput">free_function()</code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput">()</code>
+ to indicate that it is a free function.
+ </li>
+<li>
+ If a name refers to a class template, it is specified like this: <code class="computeroutput">class_template<></code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput"><></code>
+ to indicate that it is a class template.
+ </li>
+<li>
+ If a name refers to a function-like macro, it is specified like this:
+ <code class="computeroutput">MACRO()</code>;
+ that is, it is uppercase in code font and its name is followed by <code class="computeroutput">()</code> to indicate that it is a function-like
+ macro. Object-like macros appear without the trailing <code class="computeroutput">()</code>.
+ </li>
+<li>
+ Names that refer to concepts in the generic programming
+ sense are specified in CamelCase.
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ In addition, notes such as this one specify non-essential information that
+ provides additional background or rationale.
+ </td></tr>
+</table></div>
+
+ Finally, you can mentally add the following to any code fragments in this document:
+ 
+<pre class="programlisting">// Include all of the core Opaque files
+#include <boost/opaque.hpp>
+
+using namespace boost;
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.overview.motivation"></a>Motivation
+</h3></div></div></div>
+
+ The notion of "opaque typedefs" is a recurring theme (see []).
+ Boost.Serialization contains a macro which is used to define what Robert
+ calls "strong typedefs", but the implementation is not complete.
+ 
+
+ The Walter E. Brown's proposals () includes a clear motivation for "opaque
+ typedefs".
+ 
+
+ 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:
+ 
+<pre class="programlisting">struct MyType : std::string {
+ using string::string;
+};
+</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.
+ 
+
+ 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.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<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 provides:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ a generic mixin class hierarchy which can be specialized by the user
+ to make new opaque classes.
+ </li>
+<li>
+ a generic class hierarchy which can be instantiated by the user to make
+ new opaque typedefs.
+ </li>
+<li>
+ a meta-mixin concept that allows to compose in a easy way several aspects
+ of a class in an orthogonal way.
+ </li>
+<li>
+ a considerable number of meta-mixins that helps defining new types from
+ an underlying type
+ </li>
+<li>
+ Some helper macros that can reduce the declaration of a new opaque type
+ to a single line, emulating the language-based approach.
+ </li>
+</ul></div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.opaque.users_guide"></a> Users' Guide
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Getting Started</dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.users_guide.getting_started.install">
+ Installing Boost.Opaque</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.getting_started.hello_world__">Hello
+ World! </a></dt>
+</dl></dd>
+<dt>Tutorial</dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_typedef_">How
+ to define a real new typedef?</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_type_">How
+ to define a real new type?</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.return_type_for_relational_operators___opaque__boolean_">Return
+ type for relational operators: <code class="computeroutput">opaque::boolean</code></a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.opaque_typedefs">Opaque
+ typedefs</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.explicit_versus_implicit_conversions_to_the_ut">Explicit
+ versus Implicit Conversions to the UT</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.hiding_inherited_operations">Hiding
+ inherited operations</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.underlying_types_hierarchy">Underlying
+ types hierarchy</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.using_udt_as_underlying_types">Using
+ UDT as Underlying types</a></dt>
+</dl></dd>
+<dt>Examples</dt>
+<dd><dl><dt>Identifier</dt></dl></dd>
+<dt> External Resources</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.users_guide.getting_started"></a> Getting Started
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.users_guide.getting_started.install">
+ Installing Boost.Opaque</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.getting_started.hello_world__">Hello
+ World! </a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.getting_started.install"></a><a href="index.html#boost.opaque.users_guide.getting_started.install" title="
+ Installing Boost.Opaque">
+ 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 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
+ Vault Utilities directory</a>
+ 
+
+ You can also access the latest (unstable?) state from the <a href="https://svn.boost.org/svn/boost/sandbox/opaque" target="_top">Boost
+ Sandbox</a>.
+ 
+<a name="boost.opaque.users_guide.getting_started.install.building_boost_opaque"></a><h5>
+<a name="id4949128"></a>
+ <a href="index.html#boost.opaque.users_guide.getting_started.install.building_boost_opaque">Building
+ Boost.Opaque</a>
+ </h5>
+
+ There is no need to compile Boost.Opaque,
+ since it's a header only library. Just include your Boost header directory
+ in your compiler include path.
+ 
+<a name="boost.opaque.users_guide.getting_started.install.requirements"></a><h5>
+<a name="id4949160"></a>
+ Requirements
+ </h5>
+
+ Boost.Opaque depends only on Boost.Operators
+ (and all libraries it depends on).
+ 
+<a name="boost.opaque.users_guide.getting_started.install.exceptions_safety"></a><h5>
+<a name="id4949191"></a>
+ <a href="index.html#boost.opaque.users_guide.getting_started.install.exceptions_safety">Exceptions
+ safety</a>
+ </h5>
+
+ All functions in the library are exception-neutral and provide strong guarantee
+ 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 href="index.html#boost.opaque.users_guide.getting_started.install.thread_safety">Thread
+ safety</a>
+ </h5>
+
+ 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 href="index.html#boost.opaque.users_guide.getting_started.install.tested_compilers">Tested
+ compilers</a>
+ </h5>
+
+ The implementation will eventually work with most C++03 conforming compilers.
+ Current version has been tested on:
+ 
+
+ Windows with
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ MSVC 10.0
+ </li>
+<li>
+ MSVC 9.0 Express
+ </li>
+</ul></div>
+
+ Cygwin 1.5 with
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ GCC 3.4.4
+ </li></ul></div>
+
+ Cygwin 1.7 with
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ GCC 4.3.4
+ </li></ul></div>
+
+ MinGW with
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ GCC 4.4.0
+ </li>
+<li>
+ GCC 4.5.0
+ </li>
+<li>
+ GCC 4.5.0 C++0x
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Please send any questions, comments and bug reports to boost <at>
+ lists <dot> boost <dot> org.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.getting_started.hello_world__"></a><a href="index.html#boost.opaque.users_guide.getting_started.hello_world__" title="Hello
+ World! ">Hello
+ World! </a>
+</h4></div></div></div></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.users_guide.tutorial"></a>Tutorial
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_typedef_">How
+ to define a real new typedef?</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_type_">How
+ to define a real new type?</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.return_type_for_relational_operators___opaque__boolean_">Return
+ type for relational operators: <code class="computeroutput">opaque::boolean</code></a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.opaque_typedefs">Opaque
+ typedefs</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.explicit_versus_implicit_conversions_to_the_ut">Explicit
+ versus Implicit Conversions to the UT</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.hiding_inherited_operations">Hiding
+ inherited operations</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.underlying_types_hierarchy">Underlying
+ types hierarchy</a></dt>
+<dt><a href="index.html#boost.opaque.users_guide.tutorial.using_udt_as_underlying_types">Using
+ UDT as Underlying types</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.how_to_define_a_real_new_typedef_"></a><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_typedef_" title="How
+ to define a real new typedef?">How
+ to define a real new typedef?</a>
+</h4></div></div></div>
+
+ We will start with the definition of a new type identifier which is based
+ on an underlying int type and has the relational operators so it can be
+ stored on a sorted container.
+ 
+<pre class="programlisting">struct Identifier_tag;
+typedef boost::opaque::new_type< int, Identifier_tag,
+ boost::mpl::vector<
+ opaque::using_totally_ordered1
+ >
+> Identifier;
+</pre>
+
+ The declaration of a new typedef Identifier is done as follows. We need
+ to declare a specific tag that will ensure that two new types are different.
+ 
+<pre class="programlisting">struct Identifier_tag;
+</pre>
+
+ New we use the opaque new_type class which has as parameters:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ the underlying type (int),
+ </li>
+<li>
+ the unique tag of the new type (Identifier_tag),
+ </li>
+<li>
+ a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+ </li>
+</ul></div>
+
+ This will declare Identifier as new type different from int that provides
+ just the operation associated to a totallyordered
+ 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
+ 
+<pre class="programlisting">BOOST_OPAQUE_NEW_TYPE(int, Identifier, ((opaque::using_totally_ordered1)))
+</pre>
+
+ The macros is responsable to define a uniqye tag and transform the preprocessor
+ PPL sequence into a MPL sequence.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.how_to_define_a_real_new_type_"></a><a href="index.html#boost.opaque.users_guide.tutorial.how_to_define_a_real_new_type_" title="How
+ to define a real new type?">How
+ to define a real new type?</a>
+</h4></div></div></div>
+
+ In the prededing example we use a tag to ensure type unicity. When the
+ user needs to add yet some specific methods, this tag is no more necessary
+ as we need to define already a new class.
+ 
+<pre class="programlisting">class Identifier : boost::opaque::new_class<Identifier, int,
+ boost::mpl::vector<
+ opaque::using_totally_ordered1
+ >
+{
+ void print();
+ // ...
+};
+</pre>
+
+ In this case we use the mixin class new_class instead. The new_class class
+ template has asthe following arguments,
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ the class we are defining
+ </li>
+<li>
+ the underlying type (int),
+ </li>
+<li>
+ a MPL sequence of additions 'mpl::vector<opaque::using_totally_ordered1>)
+ </li>
+</ul></div>
+
+ Boost.Opaque provides a macros BOOST_OPAQUE_NEW_CLASS to simplify the preceding
+ declaration
+ 
+<pre class="programlisting">BOOST_OPAQUE_NEW_CLASS(Identifier, int, ((opaque::using_totally_ordered1)))
+{
+ void print();
+ // ...
+}
+</pre>
+
+ The macros is responsable to define a uniqye tag and transform the preprocessor
+ PPL sequence into a MPL sequence.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.return_type_for_relational_operators___opaque__boolean_"></a><a href="index.html#boost.opaque.users_guide.tutorial.return_type_for_relational_operators___opaque__boolean_" title="Return
+ type for relational operators: opaque::boolean">Return
+ 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.
+ 
+<pre class="programlisting">typedef bool Bool;
+typedef int Int;
+
+Bool f(Int a, Int b)
+{
+ if(cnd()) return 0; // 1
+ else return a > b;
+}
+</pre>
+
+ We can define an bool opaque typedef so only true_ and false_ are accepted
+ as constant expressions
+ 
+<pre class="programlisting">typedef int Int;
+typedef opaque::boolean Bool;
+
+Bool f(Int a, Int b)
+{
+ if(cnd()) return 0; // (1) Error
+ else return a > b; // (2) Error
+}
+</pre>
+
+ Now we get an error on (1) as 0 is not convertible to opaque::boolean.
+ This can be easily solved
+ 
+<pre class="programlisting">Bool f(Int a, Int b)
+{
+ if(cnd()) return opaque::false_; // OK
+ else return a > b; // (2) Error
+}
+</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.
+ 
+
+ 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.
+ 
+<pre class="programlisting">struct Int_tag;
+typedef boost::opaque::new_type<int, Int_tag, boost::mpl::vector<
+ opaque::using_integer_like<opaque::boolean>
+> > Int;
+</pre>
+
+ With this definition, the preceding example compiles and does what we are
+ expecting.
+ 
+
+ Or using the macro
+ 
+<pre class="programlisting">BOOST_OPAQUE_NEW_TYPE(int, Int, ((opaque::using_integer_like<opaque::boolean>)))
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.opaque_typedefs"></a><a href="index.html#boost.opaque.users_guide.tutorial.opaque_typedefs" title="Opaque
+ typedefs">Opaque
+ typedefs</a>
+</h4></div></div></div>
+
+ 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.
+ 
+<pre class="programlisting">// Listing 1
+// Cartesian 3D coordinate types
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X);
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Y);
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Z);
+
+// polar 3D coordinate types
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Rho);
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Theta);
+BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Phi);
+
+class PhysicsVector {
+public:
+ PhysicsVector(X, Y, Z);
+ PhysicsVector(Rho, Theta, Phi);
+ ...
+}; // 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.
+ 
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.explicit_versus_implicit_conversions_to_the_ut"></a><a href="index.html#boost.opaque.users_guide.tutorial.explicit_versus_implicit_conversions_to_the_ut" title="Explicit
+ versus Implicit Conversions to the UT">Explicit
+ versus Implicit Conversions to the UT</a>
+</h4></div></div></div></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.hiding_inherited_operations"></a><a href="index.html#boost.opaque.users_guide.tutorial.hiding_inherited_operations" title="Hiding
+ inherited operations">Hiding
+ inherited operations</a>
+</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
+ 
+<pre class="programlisting">BOOST_OPAQUE_NEW_TYPE(UT, NT, (
+ (opaque::using_ope1)
+ (opaque::using_ope2)
+ ...
+ (opaque::using_open)
+))
+</pre>
+
+ Or we can use opaque types and state explicitly which operation wil be
+ hidden.
+ 
+<pre class="programlisting">BOOST_OPAQUE_PUBLIC_OPAQUE_TYPE(UT, NT, (
+ (opaque::hiding_opeK)
+))
+</pre>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.underlying_types_hierarchy"></a><a href="index.html#boost.opaque.users_guide.tutorial.underlying_types_hierarchy" title="Underlying
+ types hierarchy">Underlying
+ types hierarchy</a>
+</h4></div></div></div></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.tutorial.using_udt_as_underlying_types"></a><a href="index.html#boost.opaque.users_guide.tutorial.using_udt_as_underlying_types" title="Using
+ UDT as Underlying types">Using
+ UDT as Underlying types</a>
+</h4></div></div></div></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.users_guide.examples"></a>Examples
+</h3></div></div></div>
+<div class="toc"><dl><dt>Identifier</dt></dl></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.users_guide.examples.identifier"></a>Identifier
+</h4></div></div></div></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.users_guide.ext_references"></a> External Resources
+</h3></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>N2141: Strong Typedefs in C++09(Revisited)</dt>
+<dd>
+ Alisdair Meredith
+ </dd>
+<dt>N1891: Progress toward Opaque Typedefs for C++0X</dt>
+<dd>
+ Walter E. Brown
+ </dd>
+<dt>N1706: Toward Opaque Typedefs in C++0X</dt>
+<dd>
+ Walter E. Brown
+ </dd>
+<dt><a href="http://www.gimpel.com/html/strong.htm" target="_top">PC-lint/FlexeLint
+ Strong Type Checking</a></dt>
+<dd>
+ Gimpel Software
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.opaque.reference"></a>Reference
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Header <boost/opaque.hpp></dt>
+<dt> Header <boost/opaque/new_class.hpp></dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.base_new_type">
+ Class Template <code class="computeroutput">base_new_type<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.new_class"> Class
+ Template <code class="computeroutput">new_class<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.opaque_static_cast">
+ Non-Member Function Template <code class="computeroutput">opaque_static_cast<></code></a></dt>
+</dl></dd>
+<dt> Header <boost/opaque/new_type.hpp></dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.reference.new_type_hpp.new_type"> Class
+ Template <code class="computeroutput">new_type<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_type_hpp.opaque_static_cast">
+ Non-Member Function Template Specialization <code class="computeroutput">opaque_static_cast<></code></a></dt>
+</dl></dd>
+<dt> Header <boost/opaque/boolean.hpp></dt>
+<dd><dl><dt><a href="index.html#boost.opaque.reference.boolean_hpp.boolean"> Class
+ <code class="computeroutput">boolean</code></a></dt></dl></dd>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_class.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.base_private_opaque_type">
+ Class <code class="computeroutput">base_private_opaque_type</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.private_opaque_class">
+ Class Template <code class="computeroutput">private_opaque_class<></code></a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_type_hpp"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_type.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.opaque.reference.private_opaque_type_hpp.private_opaque_type">
+ Class Template <code class="computeroutput">private_opaque_type<></code></a></dt></dl></dd>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_class.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.private_opaque_class">
+ Class <code class="computeroutput">base_public_opaque_type</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.get_substituables">
+ Class Template <code class="computeroutput">get_substituables<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.public_opaque_class">
+ Class Template <code class="computeroutput">public_opaque_class<></code></a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_type_hpp"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_type.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.opaque.reference.public_opaque_type_hpp.public_opaque_type">
+ Class Template <code class="computeroutput">public_opaque_type<></code></a></dt></dl></dd>
+<dt> Header <boost/opaque/macros.hpp></dt>
+<dt>Meta-Mixins</dt>
+<dd><dl>
+<dt> Concepts</dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/linear_hierarchy.hpp></code></a></dt>
+<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>
+<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>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.hiding_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.using_combined_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/using_combined_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_combined_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_substituable.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_explicit_substituable.hpp></code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.opaque_hpp"></a> Header <boost/opaque.hpp>
+</h3></div></div></div>
+
+ Include all the opaque public header files.
+ 
+<pre class="programlisting">#include <boost/opaque/opaque.hpp>
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.new_class_hpp"></a> Header <boost/opaque/new_class.hpp>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.base_new_type">
+ Class Template <code class="computeroutput">base_new_type<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.new_class"> Class
+ Template <code class="computeroutput">new_class<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_class_hpp.opaque_static_cast">
+ Non-Member Function Template <code class="computeroutput">opaque_static_cast<></code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+ class base_new_type;
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
+ >
+ class new_class;
+
+ template <
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v);
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.new_class_hpp.base_new_type"></a><a href="index.html#boost.opaque.reference.new_class_hpp.base_new_type" title="
+ Class Template base_new_type<>">
+ Class Template <code class="computeroutput">base_new_type<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">class base_new_type {};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.new_class_hpp.new_class"></a><a href="index.html#boost.opaque.reference.new_class_hpp.new_class" title=" Class
+ Template new_class<>"> Class
+ Template <code class="computeroutput">new_class<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
+>
+class new_class : public linear_hierarchy<MetaMixinSeq, Final, Base>::type
+{
+public:
+ typedef T underlying_type;
+
+ template <typename W>
+ explicit new_class(W v);
+ new_class();
+ new_class(const new_class & rhs);
+ explicit new_class(T v);
+protected:
+ T val_;
+ new_class & operator=(const new_class & rhs);
+
+public:
+ underlying_type const& underlying() const;
+ underlying_type& underlying();
+
+ template<typename F>
+ static underlying_type& underlying(F* f);
+
+ template<typename F>
+ static underlying_type const& underlying(F const* f);
+
+ template<typename F>
+ static Final const& final(F const* f);
+ template<typename F>
+ static Final& final(F* f);
+
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.new_class_hpp.opaque_static_cast"></a><a href="index.html#boost.opaque.reference.new_class_hpp.opaque_static_cast" title="
+ Non-Member Function Template opaque_static_cast<>">
+ Non-Member Function Template <code class="computeroutput">opaque_static_cast<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
+>
+T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v);
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.new_type_hpp"></a> Header <boost/opaque/new_type.hpp>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.reference.new_type_hpp.new_type"> Class
+ Template <code class="computeroutput">new_type<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.new_type_hpp.opaque_static_cast">
+ Non-Member Function Template Specialization <code class="computeroutput">opaque_static_cast<></code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+ template <
+ typename T,
+ typename Tag,
+ typename Concepts=boost::mpl::vector0<>,
+ typename Base=base_new_type>
+ class new_type;
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.new_type_hpp.new_type"></a><a href="index.html#boost.opaque.reference.new_type_hpp.new_type" title=" Class
+ Template new_type<>"> Class
+ Template <code class="computeroutput">new_type<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename T,
+ typename Tag,
+ typename Concepts,
+ typename Base
+class new_type
+ : public new_class<new_type<T, Tag, Concepts, Base>, T, Concepts, Base>
+{
+public:
+ template <typename W>
+ explicit new_type(W v);
+ new_type();
+ new_type(const new_type & rhs);
+ explicit new_type(T v);
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.new_type_hpp.opaque_static_cast"></a><a href="index.html#boost.opaque.reference.new_type_hpp.opaque_static_cast" title="
+ Non-Member Function Template Specialization opaque_static_cast<>">
+ Non-Member Function Template Specialization <code class="computeroutput">opaque_static_cast<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename T,
+ typename UT,
+ typename Tag,
+ typename Concepts,
+ typename Base
+>
+T opaque_static_cast(new_type<UT,Tag,Concepts,Base> const& v);
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.boolean_hpp"></a> Header <boost/opaque/boolean.hpp>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.boolean_hpp.boolean"> Class
+ <code class="computeroutput">boolean</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ namespace opaque {
+ class boolean;
+ }
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.boolean_hpp.boolean"></a><a href="index.html#boost.opaque.reference.boolean_hpp.boolean" title=" Class
+ boolean"> Class
+ <code class="computeroutput">boolean</code></a>
+</h4></div></div></div>
+<pre class="programlisting">class boolean {
+public:
+ explicit boolean(const bool b);
+
+ operator unspecified_bool_type() const;
+ boolean operator!() const;
+ boolean operator&&(boolean rhs) const;
+ boolean operator||(boolean rhs) const;
+};
+const boolean true_;
+const boolean false_;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.private_opaque_class_hpp"></a><a href="index.html#boost.opaque.reference.private_opaque_class_hpp" title=" Header
+ <boost/opaque/private_opaque_class.hpp>"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_class.hpp></code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.base_private_opaque_type">
+ Class <code class="computeroutput">base_private_opaque_type</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.private_opaque_class">
+ Class Template <code class="computeroutput">private_opaque_class<></code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+ class base_private_opaque_type;
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_private_opaque_type
+ >
+ class private_opaque_class;
+}
+</pre>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Can instances of UT be explicitly converted to instances of OT? Yes
+ </li>
+<li>
+ Can instances of UT be implicitly converted to instances of OT? No
+ </li>
+<li>
+ Can instances of OT be explicitly converted to instances of UT? Yes.
+ </li>
+<li>
+ Waiting for explicit conversion operators,, the explicit conversion must
+ be done through the underlying function
+ </li>
+<li>
+ Can instances of OT be implicitly converted to instances of UT? No
+ </li>
+</ul></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.private_opaque_class_hpp.base_private_opaque_type"></a><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.base_private_opaque_type" title="
+ Class base_private_opaque_type">
+ Class <code class="computeroutput">base_private_opaque_type</code></a>
+</h4></div></div></div>
+<pre class="programlisting">class base_private_opaque_type {};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.private_opaque_class_hpp.private_opaque_class"></a><a href="index.html#boost.opaque.reference.private_opaque_class_hpp.private_opaque_class" title="
+ Class Template private_opaque_class<>">
+ Class Template <code class="computeroutput">private_opaque_class<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+>
+class private_opaque_class : public
+ new_class< Final, T,
+ mpl::push<
+ transitive_explicit_substituable<base_private_opaque_type>,
+ mpl::push<
+ inherited_from_undelying<T>,
+ MetaMixinSeq
+ >
+ >,
+ Base
+ >
+{
+public:
+
+ private_opaque_class();
+ private_opaque_class(const private_opaque_class & rhs);
+ private_opaque_class(const Final & rhs);
+ explicit private_opaque_class(T v);
+ template <typename W>
+ explicit private_opaque_class(W v);
+};
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.private_opaque_type_hpp"></a><a href="index.html#boost.opaque.reference.private_opaque_type_hpp" title=" Header
+ <boost/opaque/private_opaque_type.hpp>"> Header
+ <code class="computeroutput"><boost/opaque/private_opaque_type.hpp></code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.private_opaque_type_hpp.private_opaque_type">
+ Class Template <code class="computeroutput">private_opaque_type<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_private_opaque_type
+ >
+ class private_opaque_type;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.private_opaque_type_hpp.private_opaque_type"></a><a href="index.html#boost.opaque.reference.private_opaque_type_hpp.private_opaque_type" title="
+ Class Template private_opaque_type<>">
+ Class Template <code class="computeroutput">private_opaque_type<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+>
+class private_opaque_type : public
+ private_opaque_class<
+ private_opaque_type<T,Tag,MetaMixinSeq,Base>, T, MetaMixinSeq, Base>
+{
+public:
+
+ private_opaque_type();
+ private_opaque_type(const private_opaque_class & rhs);
+ private_opaque_type(const Final & rhs);
+ explicit private_opaque_type(T v);
+ template <typename W>
+ explicit private_opaque_type(W v);
+};
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.public_opaque_class_hpp"></a><a href="index.html#boost.opaque.reference.public_opaque_class_hpp" title=" Header
+ <boost/opaque/public_opaque_class.hpp>"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_class.hpp></code></a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.private_opaque_class">
+ Class <code class="computeroutput">base_public_opaque_type</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.get_substituables">
+ Class Template <code class="computeroutput">get_substituables<></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.public_opaque_class">
+ Class Template <code class="computeroutput">public_opaque_class<></code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+ class base_public_opaque_type;
+
+ template <typename T>
+ struct get_substituables;
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+ >
+ class public_opaque_class;
+}
+</pre>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Can instances of UT be explicitly converted to instances of OT? Yes
+ </li>
+<li>
+ Can instances of UT be implicitly converted to instances of OT? No
+ </li>
+<li>
+ Can instances of OT be explicitly converted to instances of UT? Yes
+ </li>
+<li>
+ Can instances of OT be implicitly converted to instances of UT? Yes
+ </li>
+</ul></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.public_opaque_class_hpp.private_opaque_class"></a><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.private_opaque_class" title="
+ Class base_public_opaque_type">
+ Class <code class="computeroutput">base_public_opaque_type</code></a>
+</h4></div></div></div>
+<pre class="programlisting">class base_public_opaque_type {};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.public_opaque_class_hpp.get_substituables"></a><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.get_substituables" title="
+ Class Template get_substituables<>">
+ Class Template <code class="computeroutput">get_substituables<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <typename T>
+struct get_substituables {
+ typedef <see below> type;
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.public_opaque_class_hpp.public_opaque_class"></a><a href="index.html#boost.opaque.reference.public_opaque_class_hpp.public_opaque_class" title="
+ Class Template public_opaque_class<>">
+ Class Template <code class="computeroutput">public_opaque_class<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+>
+class public_opaque_class
+ : public new_class< Final, T,
+ mpl::push<
+ transitive_substituable<base_public_opaque_type>,
+ mpl::push<
+ inherited_from_undelying<T>,
+ MetaMixinSeq
+ >
+ >,
+ Base
+ >
+{
+public:
+ typedef <see below> substituables;
+
+ public_opaque_class();
+ public_opaque_class(const public_opaque_class & rhs);
+ public_opaque_class(const Final & rhs);
+ explicit public_opaque_class(T v);
+ template <typename W>
+ explicit public_opaque_class(W v);
+
+};
+</pre>
+
+ template < typename Final, typename T, typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type > class public_opaque_class :
+ public new_class< Final, T, mpl::push< transitive_substituable<base_public_opaque_type>,
+ mpl::push< inherited_from_undelying<T>, MetaMixinSeq > >,
+ Base > { public: typedef <see below> substituables;
+ 
+<pre class="programlisting"> public_opaque_class();
+ public_opaque_class(const public_opaque_class & rhs);
+ public_opaque_class(const Final & rhs);
+ explicit public_opaque_class(T v);
+ template <typename W>
+ explicit public_opaque_class(W v);
+
+};
+</pre>
+
+ public_opaque_class(); public_opaque_class(const public_opaque_class &
+ rhs); public_opaque_class(const Final & rhs); explicit public_opaque_class(T
+ v); template <typename W> explicit public_opaque_class(W v);
+ 
+<pre class="programlisting">};
+</pre>
+
+ };
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.public_opaque_type_hpp"></a><a href="index.html#boost.opaque.reference.public_opaque_type_hpp" title=" Header
+ <boost/opaque/public_opaque_type.hpp>"> Header
+ <code class="computeroutput"><boost/opaque/public_opaque_type.hpp></code></a>
+</h3></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.public_opaque_type_hpp.public_opaque_type">
+ Class Template <code class="computeroutput">public_opaque_type<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+ >
+ class public_opaque_type;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.public_opaque_type_hpp.public_opaque_type"></a><a href="index.html#boost.opaque.reference.public_opaque_type_hpp.public_opaque_type" title="
+ Class Template public_opaque_type<>">
+ Class Template <code class="computeroutput">public_opaque_type<></code></a>
+</h4></div></div></div>
+<pre class="programlisting">template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+>
+class public_opaque_type : public
+ public_opaque_class<
+ public_opaque_type<T,Tag,MetaMixinSeq,Base>, T, MetaMixinSeq, Base>
+{
+public:
+
+ public_opaque_type();
+ public_opaque_type(const public_opaque_type & rhs);
+ public_opaque_type(const Final & rhs);
+ explicit public_opaque_type(T v);
+ template <typename W>
+ explicit public_opaque_type(W v);
+};
+</pre>
+</div>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.macros_hpp"></a> Header <boost/opaque/macros.hpp>
+</h3></div></div></div></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.reference.meta_mixins"></a>Meta-Mixins
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt> Concepts</dt>
+<dd><dl>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Final">
+ <code class="computeroutput">Final</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.FinalUnderlying">
+ <code class="computeroutput">FinalUnderlying</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Mixin">
+ <code class="computeroutput">Mixin</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixin">
+ <code class="computeroutput">MetaMixin</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixinSequence">
+ <code class="computeroutput">MetaMixinSequence</code></a></dt>
+</dl></dd>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/linear_hierarchy.hpp></code></a></dt>
+<dd><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp.linear_hierarchy">
+ 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>
+<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
+ Operators</a></dt></dl></dd>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.hiding_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.using_combined_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/using_combined_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.hiding_combined_operators_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/hiding_combined_operators.hpp></code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_substituable_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_substituable.hpp></code></a></dt>
+<dd><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></dd>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.transitive_explicit_substituable_hpp">
+ Header <code class="computeroutput"><boost/opaque/metamixin/transitive_explicit_substituable.hpp></code></a></dt>
+<dd><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></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.concepts"></a> Concepts
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Final">
+ <code class="computeroutput">Final</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.FinalUnderlying">
+ <code class="computeroutput">FinalUnderlying</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Mixin">
+ <code class="computeroutput">Mixin</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixin">
+ <code class="computeroutput">MetaMixin</code></a></dt>
+<dt><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixinSequence">
+ <code class="computeroutput">MetaMixinSequence</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.concepts.Final"></a><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Final" title="
+ Final">
+ <code class="computeroutput">Final</code></a>
+</h5></div></div></div>
+
+ Classes that models the <code class="computeroutput">Final</code>
+ concept satisfy the following expressions:
+ 
+
+ Let <code class="computeroutput">B</code> a base class of
+ <code class="computeroutput">Final</code>, <code class="computeroutput">b</code> an instance of <code class="computeroutput">B</code>,
+ <code class="computeroutput">bc</code> an instance of <code class="computeroutput">B const</code>.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ <code class="computeroutput">Final::final(&b)</code>
+ return the <code class="computeroutput">Final&</code> reference associated to <code class="computeroutput">b</code>.
+ </li>
+<li>
+ <code class="computeroutput">Final::final(&b)</code>
+ returns the <code class="computeroutput">const Final&</code> reference associated to <code class="computeroutput">bc</code>.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.concepts.FinalUnderlying"></a><a href="index.html#boost.opaque.reference.meta_mixins.concepts.FinalUnderlying" title="
+ FinalUnderlying">
+ <code class="computeroutput">FinalUnderlying</code></a>
+</h5></div></div></div>
+
+ Classes that models the <code class="computeroutput">FinalUnderlying</code>
+ concept satisfy the following expressions:
+ 
+
+ Let <code class="computeroutput">B</code> a base class of
+ <code class="computeroutput">Final</code>, <code class="computeroutput">b</code> an instance of <code class="computeroutput">B</code>,
+ <code class="computeroutput">bc</code> an instance of <code class="computeroutput">B const</code>,
+ <code class="computeroutput">f</code> an instace of <code class="computeroutput">Final</code> and fc and instance of `Final
+ const '.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ <code class="computeroutput">Final::underlying_type</code> the underlying
+ type
+ </li>
+<li>
+ <code class="computeroutput">Final::underlying(&b)</code>
+ return a reference to <code class="computeroutput">Final::underlying_type&</code> associated to <code class="computeroutput">b</code>.
+ </li>
+<li>
+ <code class="computeroutput">Final::underlying(&bc)</code>
+ return a constant reference to <code class="computeroutput">Final::underlying_type
+ const&</code>
+ associated to <code class="computeroutput">bc</code>.
+ </li>
+<li>
+ <code class="computeroutput">f.underlying()</code>
+ return a reference to <code class="computeroutput">Final::underlying_type&</code> associated to <code class="computeroutput">f</code>.
+ </li>
+<li>
+ <code class="computeroutput">fc.underlying()</code>
+ return a constant reference to <code class="computeroutput">Final::underlying_type
+ const&</code>
+ associated to <code class="computeroutput">fc</code>.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.concepts.Mixin"></a><a href="index.html#boost.opaque.reference.meta_mixins.concepts.Mixin" title="
+ Mixin">
+ <code class="computeroutput">Mixin</code></a>
+</h5></div></div></div>
+
+ A Mixin is a template class having two template parameters, the Final
+ type and the Base type. The Final parameter must satisfy the Final requirements.
+ 
+
+ The archetype of a Mixin is
+ 
+<pre class="programlisting">template <typename Final, typename Base>
+struct MixinArchetype : Base
+{
+ ...
+};
+</pre>
+
+ The Final class must make the following
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.concepts.MetaMixin"></a><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixin" title="
+ MetaMixin">
+ <code class="computeroutput">MetaMixin</code></a>
+</h5></div></div></div>
+
+ A MetaMixin is a meta-function having as nested type a Mixin. The archetype
+ of a MetaMixin is
+ 
+<pre class="programlisting">struct MetaMixinArchetype {
+ template <typename Final, typename Base>
+ struct type : Base
+ {
+ ...
+ };
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.concepts.MetaMixinSequence"></a><a href="index.html#boost.opaque.reference.meta_mixins.concepts.MetaMixinSequence" title="
+ MetaMixinSequence">
+ <code class="computeroutput">MetaMixinSequence</code></a>
+</h5></div></div></div>
+
+ A <code class="computeroutput">MetaMixinSequence</code> is
+ MPL Sequence of <code class="computeroutput">MetaMixin</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.linear_hierarchy_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp" title="
+ Header <boost/opaque/metamixin/linear_hierarchy.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/linear_hierarchy.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp.linear_hierarchy">
+ Class Template <code class="computeroutput">linear_hierarchy<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template<typename MetaMixinSeq, typename Final, typename Base>
+ struct linear_hierarchy;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.linear_hierarchy_hpp.linear_hierarchy"></a><a href="index.html#boost.opaque.reference.meta_mixins.linear_hierarchy_hpp.linear_hierarchy" title="
+ Class Template linear_hierarchy<>">
+ Class Template <code class="computeroutput">linear_hierarchy<></code></a>
+</h5></div></div></div>
+
+ The <code class="computeroutput">linear_hierarchy</code>
+ metafunction gererates a linear hierarchy by folding the Mixins obtained
+ by application of the <code class="computeroutput">MetaMixin</code>
+ in <code class="computeroutput">MetaMixinSeq</code>.
+ 
+<pre class="programlisting">template<typename MetaMixinSeq, typename Final, typename Base>
+struct linear_hierarchy {
+ typedef <see below> type;
+};
+</pre>
+
+ The nested <code class="computeroutput">type</code> is equivalent
+ to <code class="computeroutput">typename boost::mpl::fold<MetaMixinSeq, Base, implementation_defined<Final> >::type</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.inherited_from_undelying_hpp" title="
+ 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>
+<pre class="programlisting">namespace boost {
+ template <typename T, typename Bool=bool>
+ struct inherited_from_undelying;
+}
+</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>
+</h5></div></div></div>
+<pre class="programlisting">template <typename T, typename Bool>
+struct inherited_from_undelying;
+</pre>
+
+ <code class="computeroutput">inherited_from_undelying</code>
+ is a <code class="computeroutput">MetaMixin</code> which
+ add wrapping member to the underlyibg type <code class="computeroutput">UT</code>.
+ 
+
+ This class must specialized for specific types in order to make easier
+ the construction of opaque types having <code class="computeroutput">UT</code>
+ as underlying type. For example the library provide specializations for
+ each one of the buil-in types.
+ 
+<pre class="programlisting">template <typename Bool>
+struct inherited_from_undelying<int> {
+ template <typename Final, typename Base>
+ struct type; //implementation defined
+};
+</pre>
+
+ template <typename Bool> struct inherited_from_undelying<int>
+ { template <typename Final, typename Base> struct type; //implementation
+ defined };
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.reference.meta_mixins.using_operators_hpp"></a><a href="index.html#boost.opaque.reference.meta_mixins.using_operators_hpp" title="
+ Header <boost/opaque/metamixin/using_operators.hpp>">
+ Header <code class="computeroutput"><boost/opaque/metamixin/using_operators.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="index.html#boost.opaque.reference.meta_mixins.using_operators_hpp.arithmetic_operators">Arithmetic
+ Operators</a></dt></dl></div>
+
+ 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 <code class="computeroutput">using_</code>.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost.opaque.reference.meta_mixins.using_operators_hpp.arithmetic_operators"></a><a href="index.html#boost.opaque.reference.meta_mixins.using_operators_hpp.arithmetic_operators" title="Arithmetic
+ Operators">Arithmetic
+ Operators</a>
+</h5></div></div></div>
+
+ The arithmetic meta-mixins ease the task of creating a custom numeric
+ type based on the underlying type. Given an underlying type, the templates
+ add forward operators from the numeric class to the underlying type.
+ These operations are like the ones the standard arithmetic types have,
+ and may include comparisons, adding, incrementing, logical and bitwise
+ manipulations, etc. Further, since most numeric types need more than
+ one of these operators, some templates are provided to combine several
+ of the basic operator templates in one declaration.
+ 
+
+ The requirements for the types used to instantiate the simple operator
+ templates are specified in terms of expressions which must be valid and
+ the expression's return type.
+ 
+
+ 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 <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.
+ 
+<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>
+<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;
+}
+</pre>
+
+ 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.
+ 
+<pre class="programlisting">template <typename BaseClass, typename UT>
+struct transitive_explicit_substituable;
+</pre>
+</div>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost.opaque.appendices"></a>Appendices
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Appendix A: History</dt>
+<dd><dl><dt>Version 0.1.0, October 18, 2010 </dt></dl></dd>
+<dt><a href="index.html#boost.opaque.appendices.rationale"> Appendix B: Design
+ Rationale</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.implementation"> Appendix C:
+ Implementation Notes</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.acknowledgements"> Appendix D:
+ Acknowledgements</a></dt>
+<dt><a href="index.html#boost.opaque.appendices.appendix_e__tests">Appendix E:
+ Tests</a></dt>
+<dd><dl><dt>Builtins</dt></dl></dd>
+<dt><a href="index.html#boost.opaque.appendices.appendix_f__tickets">Appendix
+ F: Tickets</a></dt>
+<dt> Appendix F: Future plans</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.history"></a> Appendix A: History
+</h3></div></div></div>
+<div class="toc"><dl><dt>Version 0.1.0, October 18, 2010 </dt></dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.appendices.history.__version_0_1_0__october_18__2010__"></a>Version 0.1.0, October 18, 2010
+</h4></div></div></div>
+
+ Features:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ a
+ </li></ul></div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.rationale"></a><a href="index.html#boost.opaque.appendices.rationale" title=" Appendix B: Design
+ Rationale"> Appendix B: Design
+ Rationale</a>
+</h3></div></div></div>
+<a name="boost.opaque.appendices.rationale.lala"></a><h4>
+<a name="id5005312"></a>
+ lala
+ </h4>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.implementation"></a><a href="index.html#boost.opaque.appendices.implementation" title=" Appendix C:
+ Implementation Notes"> Appendix C:
+ Implementation Notes</a>
+</h3></div></div></div>
+<a name="boost.opaque.appendices.implementation.lala"></a><h4>
+<a name="id5005345"></a>
+ lala
+ </h4>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.acknowledgements"></a><a href="index.html#boost.opaque.appendices.acknowledgements" title=" Appendix D:
+ Acknowledgements"> Appendix D:
+ Acknowledgements</a>
+</h3></div></div></div>
+
+ Thanks to .
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.appendix_e__tests"></a><a href="index.html#boost.opaque.appendices.appendix_e__tests" title="Appendix E:
+ Tests">Appendix E:
+ Tests</a>
+</h3></div></div></div>
+<div class="toc"><dl><dt>Builtins</dt></dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost.opaque.appendices.appendix_e__tests.builtins"></a>Builtins
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ kind
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Result
+ 
+ </th>
+<th>
+ 
+ Ticket
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ convert_to_with_builtin_types
+ 
+ </td>
+<td>
+ 
+ run
+ 
+ </td>
+<td>
+ 
+ check <code class="computeroutput">convert_to</code>
+ works for builting types
+ 
+ </td>
+<td>
+ 
+ Pass
+ 
+ </td>
+<td>
+ 
+ #
+ 
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+</div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost.opaque.appendices.appendix_f__tickets"></a><a href="index.html#boost.opaque.appendices.appendix_f__tickets" title="Appendix
+ F: Tickets">Appendix
+ F: Tickets</a>
+</h3></div></div></div></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<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 href="index.html#boost.opaque.appendices.todo.tasks_to_do_before_review">Tasks
+ to do before review</a>
+ </h4>
+<div class="itemizedlist"><ul type="disc"><li>
+ lala
+ </li></ul></div>
+<a name="boost.opaque.appendices.todo.for_later_releases"></a><h4>
+<a name="id5005578"></a>
+ <a href="index.html#boost.opaque.appendices.todo.for_later_releases">For later
+ releases</a>
+ </h4>
+<div class="itemizedlist"><ul type="disc"><li>
+ lala
+ </li></ul></div>
+</div>
+</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="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>

Added: sandbox/opaque/libs/opaque/doc/html/standalone_HTML.manifest
==============================================================================
--- (empty file)
+++ sandbox/opaque/libs/opaque/doc/html/standalone_HTML.manifest 2010-10-02 18:44:55 EDT (Sat, 02 Oct 2010)
@@ -0,0 +1 @@
+index.html

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-02 18:44:55 EDT (Sat, 02 Oct 2010)
@@ -8,11 +8,11 @@

[article Toward Boost.Opaque
 [quickbook 1.5]
+ [version 0.1.0]
 [authors [Botet Escriba, Vicente J.]]
 [copyright 2010 Vicente J. Botet Escriba]
 [id boost.opaque]
 [dirname opaque]
- [purpose Opaque typdef emulation]
 [license
 Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,12 +20,14 @@
 ]
]

+[:["Strong type checking is gold;
+ normal type checking is silver;
+ and casting is brass]]
+[:[*['-- ]]]

[/
[section Preface]

-[:[".]]
-[:[*['-- ]]]

[endsect]
/]
@@ -36,20 +38,8 @@
[section Overview]
[/========================]

-[/==================]
-[heading Description]
-[/==================]

-The notion of "opaque typedefs" is a recurring theme (see []), but this will not be part of the C++0x standard. Boost.Serialization contains a macro which is used to define what Robert calls "strong typedefs", but the implementation is not complete.
-
-Boost.Opaque intends to provide a library partial solution to this problem.
-
-[*Boost.Opaque] provides:
-
-* a generic mixin class which can be specialized by the user to make opaque typedefs.
-* Some helper macros
-
[/====================================]
[heading How to Use This Documentation]
[/====================================]
@@ -77,8 +67,12 @@

[section Motivation]

-The characteristic feature desired of an opaque typedef is the ability to overload functions and operators based on one or more newly-defined opaque-types. For example, we would wish to overload the constructors in a PhysicsVector class such that each constructor corresponds to a distinct coordinate
-system. Temporarily using a notional opaque keyword, we might code this as:
+The notion of "opaque typedefs" is a recurring theme (see []). Boost.Serialization contains a macro which is used to define what Robert calls "strong typedefs", but the implementation is not complete.
+
+The Walter E. Brown's proposals () includes a clear motivation for "opaque typedefs".
+
+[/
+The characteristic feature desired of an opaque typedef is the ability to overload functions and operators based on one or more newly-defined opaque-types. For example, we would wish to overload the constructors in a `PhysicsVector` class such that each constructor corresponds to a distinct coordinate system. Using Boost/Opaque, we can code this as:

 // Listing 1
 // Cartesian 3D coordinate types
@@ -98,16 +92,42 @@
 ...
 }; // PhysicsVector

-In this way, a compiler would be able to diagnose usages that accidentally provided coordinates in an unsupported order or in an unsupported mixture of coordinate systems. While this can be accomplished in C++03 by inventing classes for each of the coordinates, this is generally viewed as a fairly heavy burden: the above code would require six near-identical classes, each wrapping a single value in the same way, differing only by name.
+In this way, a compiler would be able to diagnose usages that accidentally provided coordinates in an unsupported order or in an unsupported mixture of coordinate systems. While this can be accomplished by inventing flat classes for each of the coordinates, this is generally viewed as a fairly heavy burden: the above code would require six near-identical classes, each wrapping a single value in the same way, differing only by name.

-As a natural consequence of this required overloading capability, we propose that an underlying type UT shall meet all requirements of TR1 such that is_convertible<OT,UT>::value is well-formed for any opaque-type OT for which UT serves as underlying-type. (This requires, for example, that UT be non-void, and that it not be an incomplete type.)
+As a natural consequence of this required overloading capability, an underlying type `UT` meets `is_convertible<OT,UT>::value` is well-formed for any opaque-type `OT` for which `UT` serves as underlying-type. (This requires, for example, that `UT` be non-void, and that it not be an incomplete type.)

-In addition, the underlying-type UT can not be cv-qualified. This restriction
-is consistent with two important C++03 precedents:
+In addition, the underlying-type `UT` can not be cv-qualified. This restriction is consistent with two important precedents:

-# The underlying type of an enum has no provision that permits its underlying type to be cv-qualified.
+# The underlying type of an enum has no provision that permits its underlying type to be cv-qualified.
# 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:
+
+ 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.
+
+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.
+
+
+[endsect]
+[/==================]
+[section Description]
+[/==================]
+
+
+Boost.Opaque intends to provide a library partial solution to this problem.

+[*Boost.Opaque] provides:
+
+* a generic mixin class hierarchy which can be specialized by the user to make new opaque classes.
+* a generic class hierarchy which can be instantiated by the user to make new opaque typedefs.
+* a meta-mixin concept that allows to compose in a easy way several aspects of a class in an orthogonal way.
+* a considerable number of meta-mixins that helps defining new types from an underlying type
+* Some helper macros that can reduce the declaration of a new opaque type to a single line, emulating the language-based approach.

[endsect]
[endsect]
@@ -152,8 +172,7 @@
[heading Exceptions safety]
[/========================]

-All functions in the library are exception-neutral and provide strong guarantee of exception safety as long as
-the underlying parameters provide it.
+All functions in the library are exception-neutral and provide strong guarantee of exception safety as long as the underlying parameters provide it.

[/====================]
[heading Thread safety]
@@ -164,12 +183,28 @@
[/=======================]
[heading Tested compilers]
[/=======================]
-Currently, [*Boost.Opaque] has been tested in the following compilers/platforms:

-* GCC 3.4.4 Cygwin
-* GCC 3.4.6 Linux
-[/* GCC 4.3.2 Cygwin]
-* GCC 4.1.2 Linux
+The implementation will eventually work with most C++03 conforming compilers.
+Current version has been tested on:
+
+Windows with
+
+* MSVC 10.0
+* MSVC 9.0 Express
+
+Cygwin 1.5 with
+
+* GCC 3.4.4
+
+Cygwin 1.7 with
+
+* GCC 4.3.4
+
+MinGW with
+
+* GCC 4.4.0
+* GCC 4.5.0
+* GCC 4.5.0 C++0x

[note Please send any questions, comments and bug reports to boost <at> lists <dot> boost <dot> org.]

@@ -179,29 +214,223 @@
[/=============================]

+
+
+
[endsect]

[endsect]

[section Tutorial]

-[section lala]
+[section How to define a real new typedef?]
+
+We will start with the definition of a new type identifier which is based on an underlying int type and has the relational operators so it can be stored on a sorted container.
+
+ struct Identifier_tag;
+ typedef boost::opaque::new_type< int, Identifier_tag,
+ boost::mpl::vector<
+ opaque::using_totally_ordered1
+ >
+ > Identifier;
+
+The declaration of a new typedef Identifier is done as follows. We need to declare a specific tag that will ensure that two new types are different.
+
+ struct Identifier_tag;
+
+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>)
+
+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_NEW_TYPE(int, Identifier, ((opaque::using_totally_ordered1)))
+
+The macros is responsable to define a uniqye tag and transform the preprocessor PPL sequence into a MPL sequence.
+
+[endsect]
+
+[section How to define a real new type?]
+
+In the prededing example we use a tag to ensure type unicity. When the user needs to add yet some specific methods, this tag is no more necessary as we need to define already a new class.
+
+ class Identifier : boost::opaque::new_class<Identifier, int,
+ boost::mpl::vector<
+ opaque::using_totally_ordered1
+ >
+ {
+ void print();
+ // ...
+ };
+
+In this case we use the mixin class new_class instead. The new_class class template has asthe following arguments,
+
+* the class we are defining
+* 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_NEW_CLASS(Identifier, int, ((opaque::using_totally_ordered1)))
+ {
+ void print();
+ // ...
+ }
+
+The macros is responsable to define a uniqye 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.
+
+ typedef bool Bool;
+ typedef int Int;
+
+ Bool f(Int a, Int b)
+ {
+ if(cnd()) return 0; // 1
+ else return a > b;
+ }
+
+We can define an bool opaque typedef so only true_ and false_ are accepted as constant expressions
+
+ typedef int Int;
+ typedef opaque::boolean Bool;
+
+ Bool f(Int a, Int b)
+ {
+ if(cnd()) return 0; // (1) Error
+ 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
+
+ Bool f(Int a, Int b)
+ {
+ if(cnd()) return opaque::false_; // OK
+ 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.
+
+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<
+ opaque::using_integer_like<opaque::boolean>
+ > > Int;
+
+With this definition, the preceding example compiles and does what we are expecting.
+
+Or using the macro
+
+ BOOST_OPAQUE_NEW_TYPE(int, Int, ((opaque::using_integer_like<opaque::boolean>)))
+
+
+[endsect]
+
+[section Opaque typedefs]
+
+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.
+
+ // Listing 1
+ // Cartesian 3D coordinate types
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, X);
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Y);
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Z);
+
+ // polar 3D coordinate types
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Rho);
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Theta);
+ BOOST_OPAQUE_PUBLIC_TYPEDEF(double, Phi);
+
+ class PhysicsVector {
+ public:
+ PhysicsVector(X, Y, Z);
+ PhysicsVector(Rho, Theta, Phi);
+ ...
+ }; // 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.
+
+[endsect]
+
+[section Explicit versus Implicit Conversions to the UT]
+
+[endsect]
+
+[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
+
+ BOOST_OPAQUE_NEW_TYPE(UT, NT, (
+ (opaque::using_ope1)
+ (opaque::using_ope2)
+ ...
+ (opaque::using_open)
+ ))
+
+Or we can use opaque types and state explicitly which operation wil be hidden.
+
+ BOOST_OPAQUE_PUBLIC_OPAQUE_TYPE(UT, NT, (
+ (opaque::hiding_opeK)
+ ))
+
+
+
+[endsect]
+[section Underlying types hierarchy]

[endsect]

+[section Using UDT as Underlying types]

[endsect]

+[endsect]
+
+[section Examples]
+[section Identifier]
+
+
+[endsect]
+[endsect]
+
+
+
+[section:ext_references External Resources]

-[section:ext_references References]
[variablelist
[
-
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2141.html [*N2141: Strong Typedefs in C++09(Revisited)]]]
+ [Alisdair Meredith]
+]
+
+[
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf [*N1891: Progress toward Opaque Typedefs for C++0X]]]
+ [Walter E. Brown]
+]
+
[
- [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf [*Progress toward Opaque Typedefs for C++0X]]]
+ [[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1706.pdf [*N1706: Toward Opaque Typedefs in C++0X]]]
 [Walter E. Brown]
]

+[
+ [[@http://www.gimpel.com/html/strong.htm [*PC-lint/FlexeLint Strong Type Checking]]]
+ [Gimpel Software]
+]
+
]

[endsect]
@@ -212,10 +441,10 @@
[section Reference]

[/==========================================================================================]
-[section:conversion_hpp Header `<boost/opaque.hpp>`]
+[section:opaque_hpp Header `<boost/opaque.hpp>`]
[/==========================================================================================]

-Include all the opaque public header files.
+Include all the opaque public header files.

 #include <boost/opaque/opaque.hpp>

@@ -223,18 +452,665 @@

[/==========================================================================================]
-[section:convert_to_hpp Header `<boost/opaque/opaque.hpp>`]
+[section:new_class_hpp Header `<boost/opaque/new_class.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ class base_new_type;
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
+ >
+ class new_class;
+
+ template <
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v);
+ }
+
+[/==========================================================================================]
+[section:base_new_type Class Template `base_new_type<>`]
+[/==========================================================================================]
+
+ class base_new_type {};
+
+[endsect]
+
+[/==========================================================================================]
+[section:new_class Class Template `new_class<>`]
[/==========================================================================================]

+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_new_type
+ >
+ class new_class : public linear_hierarchy<MetaMixinSeq, Final, Base>::type
+ {
+ public:
+ typedef T underlying_type;
+
+ template <typename W>
+ explicit new_class(W v);
+ new_class();
+ new_class(const new_class & rhs);
+ explicit new_class(T v);
+ protected:
+ T val_;
+ new_class & operator=(const new_class & rhs);
+
+ public:
+ underlying_type const& underlying() const;
+ underlying_type& underlying();
+
+ template<typename F>
+ static underlying_type& underlying(F* f);
+
+ template<typename F>
+ static underlying_type const& underlying(F const* f);
+
+ template<typename F>
+ static Final const& final(F const* f);
+ template<typename F>
+ static Final& final(F* f);
+
+ };
+
+
[endsect]

+[/==========================================================================================]
+[section:opaque_static_cast Non-Member Function Template `opaque_static_cast<>`]
+[/==========================================================================================]
+
+ template <
+ typename T,
+ typename Final,
+ typename UT,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ T opaque_static_cast(new_class<Final, UT, MetaMixinSeq, Base> const& v);
+
[endsect]

-[section Examples]
-[section lala]
+[endsect]
+[/==========================================================================================]
+[section:new_type_hpp Header `<boost/opaque/new_type.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template <
+ typename T,
+ typename Tag,
+ typename Concepts=boost::mpl::vector0<>,
+ typename Base=base_new_type>
+ class new_type;
+
+[/==========================================================================================]
+[section:new_type Class Template `new_type<>`]
+[/==========================================================================================]
+
+ template <
+ typename T,
+ typename Tag,
+ typename Concepts,
+ typename Base
+ class new_type
+ : public new_class<new_type<T, Tag, Concepts, Base>, T, Concepts, Base>
+ {
+ public:
+ template <typename W>
+ explicit new_type(W v);
+ new_type();
+ new_type(const new_type & rhs);
+ explicit new_type(T v);
+ };
+
+
+[endsect]
+
+[/==========================================================================================]
+[section:opaque_static_cast Non-Member Function Template Specialization `opaque_static_cast<>`]
+[/==========================================================================================]
+
+ template <
+ typename T,
+ typename UT,
+ typename Tag,
+ typename Concepts,
+ typename Base
+ >
+ T opaque_static_cast(new_type<UT,Tag,Concepts,Base> const& v);
+
+[endsect]
+
+[endsect]
+
+[/==========================================================================================]
+[section:boolean_hpp Header `<boost/opaque/boolean.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ namespace opaque {
+ class boolean;
+ }
+ }
+
+
+[/==========================================================================================]
+[section:boolean Class `boolean`]
+[/==========================================================================================]
+
+ class boolean {
+ public:
+ explicit boolean(const bool b);
+
+ operator unspecified_bool_type() const;
+ boolean operator!() const;
+ boolean operator&&(boolean rhs) const;
+ boolean operator||(boolean rhs) const;
+ };
+ const boolean true_;
+ const boolean false_;
+
+[endsect]
+
+
+[endsect]
+
+
+
+[/==========================================================================================]
+[section:private_opaque_class_hpp Header `<boost/opaque/private_opaque_class.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ class base_private_opaque_type;
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_private_opaque_type
+ >
+ class private_opaque_class;
+ }
+
+* Can instances of UT be explicitly converted to instances of OT? Yes
+* Can instances of UT be implicitly converted to instances of OT? No
+* Can instances of OT be explicitly converted to instances of UT? Yes.
+* Waiting for explicit conversion operators,, the explicit conversion must be done through the underlying function
+* Can instances of OT be implicitly converted to instances of UT? No
+
+
+[/==========================================================================================]
+[section:base_private_opaque_type Class `base_private_opaque_type`]
+[/==========================================================================================]
+
+ class base_private_opaque_type {};
+
+[endsect]
+
+[/==========================================================================================]
+[section:private_opaque_class Class Template `private_opaque_class<>`]
+[/==========================================================================================]
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ class private_opaque_class : public
+ new_class< Final, T,
+ mpl::push<
+ transitive_explicit_substituable<base_private_opaque_type>,
+ mpl::push<
+ inherited_from_undelying<T>,
+ MetaMixinSeq
+ >
+ >,
+ Base
+ >
+ {
+ public:
+
+ private_opaque_class();
+ private_opaque_class(const private_opaque_class & rhs);
+ private_opaque_class(const Final & rhs);
+ explicit private_opaque_class(T v);
+ template <typename W>
+ explicit private_opaque_class(W v);
+ };

+[endsect]
+
+[endsect]
+
+[/==========================================================================================]
+[section:private_opaque_type_hpp Header `<boost/opaque/private_opaque_type.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_private_opaque_type
+ >
+ class private_opaque_type;
+ }
+
+[/==========================================================================================]
+[section:private_opaque_type Class Template `private_opaque_type<>`]
+[/==========================================================================================]
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ class private_opaque_type : public
+ private_opaque_class<
+ private_opaque_type<T,Tag,MetaMixinSeq,Base>, T, MetaMixinSeq, Base>
+ {
+ public:
+
+ private_opaque_type();
+ private_opaque_type(const private_opaque_class & rhs);
+ private_opaque_type(const Final & rhs);
+ explicit private_opaque_type(T v);
+ template <typename W>
+ explicit private_opaque_type(W v);
+ };
+
+
+
+[endsect]
+[endsect]
+
+[/==========================================================================================]
+[section:public_opaque_class_hpp Header `<boost/opaque/public_opaque_class.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ class base_public_opaque_type;
+
+ template <typename T>
+ struct get_substituables;
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+ >
+ class public_opaque_class;
+ }
+
+* Can instances of UT be explicitly converted to instances of OT? Yes
+* Can instances of UT be implicitly converted to instances of OT? No
+* Can instances of OT be explicitly converted to instances of UT? Yes
+* Can instances of OT be implicitly converted to instances of UT? Yes
+
+[/==========================================================================================]
+[section:private_opaque_class Class `base_public_opaque_type`]
+[/==========================================================================================]
+
+ class base_public_opaque_type {};
+
+[endsect]
+[/==========================================================================================]
+[section:get_substituables Class Template `get_substituables<>`]
+[/==========================================================================================]
+
+ template <typename T>
+ struct get_substituables {
+ typedef <see below> type;
+ }
+
+[endsect]
+
+[/==========================================================================================]
+[section:public_opaque_class Class Template `public_opaque_class<>`]
+[/==========================================================================================]
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+ >
+ class public_opaque_class
+ : public new_class< Final, T,
+ mpl::push<
+ transitive_substituable<base_public_opaque_type>,
+ mpl::push<
+ inherited_from_undelying<T>,
+ MetaMixinSeq
+ >
+ >,
+ Base
+ >
+ {
+ public:
+ typedef <see below> substituables;
+
+ public_opaque_class();
+ public_opaque_class(const public_opaque_class & rhs);
+ public_opaque_class(const Final & rhs);
+ explicit public_opaque_class(T v);
+ template <typename W>
+ explicit public_opaque_class(W v);
+
+ };
+[endsect]
+
+
+[endsect]
+
+[/==========================================================================================]
+[section:public_opaque_type_hpp Header `<boost/opaque/public_opaque_type.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq=boost::mpl::vector0<>,
+ typename Base=base_public_opaque_type
+ >
+ class public_opaque_type;
+ }
+
+[/==========================================================================================]
+[section:public_opaque_type Class Template `public_opaque_type<>`]
+[/==========================================================================================]
+
+ template <
+ typename Final,
+ typename T,
+ typename MetaMixinSeq,
+ typename Base
+ >
+ class public_opaque_type : public
+ public_opaque_class<
+ public_opaque_type<T,Tag,MetaMixinSeq,Base>, T, MetaMixinSeq, Base>
+ {
+ public:
+
+ public_opaque_type();
+ public_opaque_type(const public_opaque_type & rhs);
+ public_opaque_type(const Final & rhs);
+ explicit public_opaque_type(T v);
+ template <typename W>
+ explicit public_opaque_type(W v);
+ };
+
+[endsect]
+[endsect]
+
+
+[/==========================================================================================]
+[section:macros_hpp Header `<boost/opaque/macros.hpp>`]
+[/==========================================================================================]
+
+
+
+[endsect]
+
+
+[section Meta-Mixins]
+
+[/==========================================================================================]
+[section:concepts Concepts]
+[/==========================================================================================]
+
+[/==========================================================================================]
+[section:Final `Final`]
+[/==========================================================================================]
+
+Classes that models the `Final` concept satisfy the following expressions:
+
+Let `B` a base class of `Final`, `b` an instance of `B`, `bc` an instance of `B const`.
+
+* `Final::final(&b)` return the `Final&` reference associated to `b`.
+
+* `Final::final(&b)` returns the `const Final&` reference associated to `bc`.
+
+
+
+[endsect]
+
+[/==========================================================================================]
+[section:FinalUnderlying `FinalUnderlying`]
+[/==========================================================================================]
+
+Classes that models the `FinalUnderlying` concept satisfy the following expressions:
+
+Let `B` a base class of `Final`, `b` an instance of `B`, `bc` an instance of `B const`, `f` an instace of `Final` and fc and instance of `Final const '.
+
+* `Final::underlying_type` the underlying type
+* `Final::underlying(&b)` return a reference to `Final::underlying_type&` associated to `b`.
+* `Final::underlying(&bc)` return a constant reference to `Final::underlying_type const&` associated to `bc`.
+* `f.underlying()` return a reference to `Final::underlying_type&` associated to `f`.
+* `fc.underlying()` return a constant reference to `Final::underlying_type const&` associated to `fc`.
+
+
+[endsect]
+
+
+[/==========================================================================================]
+[section:Mixin `Mixin`]
+[/==========================================================================================]
+
+A Mixin is a template class having two template parameters, the Final type and the Base type. The Final parameter must satisfy the Final requirements.
+
+The archetype of a Mixin is
+
+ template <typename Final, typename Base>
+ struct MixinArchetype : Base
+ {
+ ...
+ };
+
+The Final class must make the following
+
+[endsect]
+
+[/==========================================================================================]
+[section:MetaMixin `MetaMixin`]
+[/==========================================================================================]
+
+A MetaMixin is a meta-function having as nested type a Mixin. The archetype of a MetaMixin is
+
+ struct MetaMixinArchetype {
+ template <typename Final, typename Base>
+ struct type : Base
+ {
+ ...
+ };
+ };
+
+[endsect]
+
+[/==========================================================================================]
+[section:MetaMixinSequence `MetaMixinSequence`]
+[/==========================================================================================]
+
+A `MetaMixinSequence` is MPL Sequence of `MetaMixin`.
+
+[endsect]
+
+[endsect]
+
+[/==========================================================================================]
+[section:linear_hierarchy_hpp Header `<boost/opaque/metamixin/linear_hierarchy.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template<typename MetaMixinSeq, typename Final, typename Base>
+ struct linear_hierarchy;
+ }
+
+[/==========================================================================================]
+[section:linear_hierarchy Class Template `linear_hierarchy<>`]
+[/==========================================================================================]
+
+The `linear_hierarchy` metafunction gererates a linear hierarchy by folding the Mixins obtained by application of the `MetaMixin` in `MetaMixinSeq`.
+
+ template<typename MetaMixinSeq, typename Final, typename Base>
+ struct linear_hierarchy {
+ typedef <see below> type;
+ };
+
+The nested `type` is equivalent to `typename boost::mpl::fold<MetaMixinSeq, Base, implementation_defined<Final> >::type`.
+
+[endsect]
+[endsect]
+
+[/==========================================================================================]
+[section:inherited_from_undelying_hpp Header `<boost/opaque/metamixin/inherited_from_undelying.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template <typename T, typename Bool=bool>
+ struct inherited_from_undelying;
+ }
+
+[/==========================================================================================]
+[section:linear_hierarchy Class Template `linear_hierarchy<>`]
+[/==========================================================================================]
+
+ template <typename T, typename Bool>
+ struct inherited_from_undelying;
+
+`inherited_from_undelying` is a `MetaMixin` which add 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.
+
+ template <typename Bool>
+ struct inherited_from_undelying<int> {
+ template <typename Final, typename Base>
+ struct type; //implementation defined
+ };
+[endsect]
+
+[endsect]
+
+[/==========================================================================================]
+[section:using_operators_hpp Header `<boost/opaque/metamixin/using_operators.hpp>`]
+[/==========================================================================================]
+
+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_`.
+
+
+[section Arithmetic Operators]
+
+The arithmetic meta-mixins ease the task of creating a custom numeric type based on the underlying type. Given an underlying type, the templates add forward operators from the numeric class to the underlying type. These operations are like the ones the standard arithmetic types have, and may include comparisons, adding, incrementing, logical and bitwise manipulations, etc. Further, since most numeric types need more than one of these operators, some templates are provided to combine several of the basic operator templates in one declaration.
+
+The requirements for the types used to instantiate the simple operator templates are specified in terms of expressions which must be valid and the expression's return type.
+
+
+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.
+
+[endsect]
+[endsect]
+
+[/==========================================================================================]
+[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.
+
+These metamixins have names that follows the naming used in Boost.ConceptsTraits, but prefixed by `hiding_`.
+
+[endsect]
+
+[/==========================================================================================]
+[section:using_combined_operators_hpp Header `<boost/opaque/metamixin/using_combined_operators.hpp>`]
+[/==========================================================================================]
+
+This file includes metamixins combining several operators.
+
+These metamixins 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.
+
+
+[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.
+
+These metamixins have names that follows the naming used in Boost.Operators, but prefixed by `hiding_`.
+
+[endsect]
+
+[/==========================================================================================]
+[section:transitive_substituable_hpp Header `<boost/opaque/metamixin/transitive_substituable.hpp>`]
+[/==========================================================================================]
+
+ namespace boost {
+ template <typename BaseClass, typename UT>
+ struct transitive_substituable;
+ }
+
+[/==========================================================================================]
+[section:transitive_substituable Class Template `transitive_substituable<>`]
+[/==========================================================================================]
+
+This metamixin provides the Final class implicit conversions for all the underlying types hierarchy.
+
+ template <typename BaseClass, typename UT>
+ struct transitive_substituable;
+
+[endsect]
+
+[endsect]
+
+[/==========================================================================================]
+[section:transitive_explicit_substituable_hpp Header `<boost/opaque/metamixin/transitive_explicit_substituable.hpp>`]
+[/==========================================================================================]
+
+[/==========================================================================================]
+[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.
+
+ template <typename BaseClass, typename UT>
+ struct transitive_explicit_substituable;
+
+
+[endsect]
+
+[endsect]

[endsect]
[endsect]
@@ -246,17 +1122,17 @@
[section:history Appendix A: History]

-[section [*Version 0.1.0, July 18, 2010] ['Announcement of Opaque]]
+[section [*Version 0.1.0, October 18, 2010] ]

[*Features:]

-* a
+* a

[endsect]
[endsect]

-[section:rationale Appendix B: Rationale]
+[section:rationale Appendix B: Design Rationale]

[heading lala]

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65732 - in sandbox/opaque/boost/opaque: . meta_mixin"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r65730 - in sandbox/opaque/libs/opaque: example test"

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