Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r69190 - in sandbox/endian_ext/libs/integer/endian: doc doc/html doc/html/toward_boost_integer_endian example test
From: vicente.botet_at_[hidden]
Date: 2011-02-22 17:56:04


Author: viboes
Date: 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
New Revision: 69190
URL: http://svn.boost.org/trac/boost/changeset/69190

Log:
Endian:
Binary files modified:
   sandbox/endian_ext/libs/integer/endian/doc/integer_endian.pdf
Text files modified:
   sandbox/endian_ext/libs/integer/endian/doc/html/index.html | 4
   sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/appendices.html | 16
   sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/overview.html | 48 +-
   sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/reference.html | 529 +++++++++++++------------
   sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/users_guide.html | 809 +++++++++++++++++++++++----------------
   sandbox/endian_ext/libs/integer/endian/doc/integer_endian.qbk | 322 ++++++++++----
   sandbox/endian_ext/libs/integer/endian/example/packet_example.cpp | 2
   sandbox/endian_ext/libs/integer/endian/test/Jamfile.v2 | 4
   sandbox/endian_ext/libs/integer/endian/test/endian_convert_test.cpp | 6
   sandbox/endian_ext/libs/integer/endian/test/endian_convert_unique_endian_test.cpp | 4
   10 files changed, 1015 insertions(+), 729 deletions(-)

Modified: sandbox/endian_ext/libs/integer/endian/doc/html/index.html
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/html/index.html (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/html/index.html 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -34,7 +34,7 @@
 <div><p class="copyright">Copyright &#169; 2006 -2010 Beman Dawes</p></div>
 <div><p class="copyright">Copyright &#169; 2010 -2011 Vicente J. Botet Escriba</p></div>
 <div><div class="legalnotice">
-<a name="id2893862"></a><p>
+<a name="id3353501"></a><p>
         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)
       </p>
@@ -110,7 +110,7 @@
 </table></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: February 18, 2011 at 22:47:19 GMT</small></p></td>
+<td align="left"><p><small>Last revised: February 22, 2011 at 22:53:16 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/appendices.html
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/appendices.html (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/appendices.html 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -67,7 +67,7 @@
 <a name="toward_boost_integer_endian.appendices.history.__version_0_2_0__febraury_15__2011__"></a><a class="link" href="appendices.html#toward_boost_integer_endian.appendices.history.__version_0_2_0__febraury_15__2011__" title="Version 0.2.0, Febraury 15, 2011"><span class="bold"><strong>Version 0.2.0, Febraury 15, 2011</strong></span> </a>
 </h4></div></div></div>
 <p>
- Move to boost/integer/endian directory.
+ Moved to boost/integer/endian directory.
         </p>
 </div>
 <div class="section">
@@ -139,7 +139,7 @@
       B: Rationale</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.rationale.design_considerations_for__emphasis_role__bold__boost_integer_endian_ext__emphasis_"></a><h5>
-<a name="id2938865"></a>
+<a name="id3399847"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.rationale.design_considerations_for__emphasis_role__bold__boost_integer_endian_ext__emphasis_">Design
         considerations for <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span></a>
       </h5>
@@ -179,7 +179,7 @@
           </li>
 </ul></div>
 <a name="toward_boost_integer_endian.appendices.rationale.experience"></a><h5>
-<a name="id2938973"></a>
+<a name="id3399954"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.rationale.experience">Experience</a>
       </h5>
 <p>
@@ -190,7 +190,7 @@
         widely useful across a wide range of computer architectures and applications.
       </p>
 <a name="toward_boost_integer_endian.appendices.rationale.motivating_use_cases"></a><h5>
-<a name="id2939006"></a>
+<a name="id3399994"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.rationale.motivating_use_cases">Motivating
         use cases</a>
       </h5>
@@ -202,7 +202,7 @@
         and cleans the code wonderfully."
       </p>
 <a name="toward_boost_integer_endian.appendices.rationale.c__0x"></a><h5>
-<a name="id2939043"></a>
+<a name="id3400032"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.rationale.c__0x">C++0x</a>
       </h5>
 <p>
@@ -217,7 +217,7 @@
       C: Implementation Notes</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.implementation.faq"></a><h5>
-<a name="id2939091"></a>
+<a name="id3400080"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.implementation.faq">FAQ</a>
       </h5>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
@@ -989,7 +989,7 @@
       G: Future plans</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.todo.tasks_to_do_before_review"></a><h5>
-<a name="id2940591"></a>
+<a name="id3401578"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.todo.tasks_to_do_before_review">Tasks
         to do before review</a>
       </h5>
@@ -1008,7 +1008,7 @@
           </li>
 </ul></div>
 <a name="toward_boost_integer_endian.appendices.todo.for_later_releases"></a><h5>
-<a name="id2940643"></a>
+<a name="id3401630"></a>
         <a class="link" href="appendices.html#toward_boost_integer_endian.appendices.todo.for_later_releases">For
         later releases</a>
       </h5>

Modified: sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/overview.html
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/overview.html (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/overview.html 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -31,7 +31,7 @@
 <dt><span class="section">Description</span></dt>
 </dl></div>
 <a name="toward_boost_integer_endian.overview.how_to_use_this_documentation"></a><h4>
-<a name="id2893910"></a>
+<a name="id3353550"></a>
       <a class="link" href="overview.html#toward_boost_integer_endian.overview.how_to_use_this_documentation">How
       to Use This Documentation</a>
     </h4>
@@ -123,16 +123,16 @@
         on top of the Beman's design endian unaware operation. Next follows some
         of the main critics that have been done recently.
       </p>
-<a name="toward_boost_integer_endian.overview.motivation.intrusive_verus_non_intrusive"></a><h5>
-<a name="id2852622"></a>
- <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.intrusive_verus_non_intrusive">Intrusive
- verus non-intrusive</a>
+<a name="toward_boost_integer_endian.overview.motivation.intrusive_versus_non_intrusive"></a><h5>
+<a name="id3312262"></a>
+ <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.intrusive_versus_non_intrusive">Intrusive
+ versus non-intrusive</a>
       </h5>
 <p>
- Endian conversion must be possible to any type even if you can't modify the
- original source code. Many people think that originel Beman's library requires
- the data types which need to be converted to be coded using his endian types
- as members.
+ Endian conversion must be possible for any type even if you can't modify
+ the original source code. Many people think that originel Beman's library
+ requires the data types which need to be converted to be coded using his
+ endian types as members.
       </p>
 <p>
         We will see that this is not true, as the user can always use casting to
@@ -149,7 +149,7 @@
 <span class="identifier">as_endian</span><span class="special">&lt;</span><span class="identifier">native</span><span class="special">&gt;(</span><span class="identifier">st_b</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">as_endian</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">&gt;(</span><span class="identifier">st_a</span><span class="special">);</span>
 </pre>
 <a name="toward_boost_integer_endian.overview.motivation.physical_versus_logical_data"></a><h5>
-<a name="id2852817"></a>
+<a name="id3312456"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.physical_versus_logical_data">Physical
         versus Logical data</a>
       </h5>
@@ -163,7 +163,7 @@
         and the other representing the logical data. Many people think that this
         means that the user has to maintain two separate structs/classes when only
         one is needed. This could be sometimes the case, but in other cases, the
- user will store the information elements include in the message on local
+ user will store the information elements included in the message on local
         variables and specific contexts that don't follow the external format.
       </p>
 <p>
@@ -181,7 +181,7 @@
         is the best adapted.
       </p>
 <a name="toward_boost_integer_endian.overview.motivation.inherent_inefficient_arithmetic_operations"></a><h5>
-<a name="id2852877"></a>
+<a name="id3312517"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.inherent_inefficient_arithmetic_operations">Inherent
         inefficient arithmetic operations</a>
       </h5>
@@ -213,8 +213,9 @@
 <span class="special">};</span>
 </pre>
 <p>
- Structure endian_aware_structure can not be used without converting to native
- types, as endian_pack don't provide other operations than conversion.
+ Structure <code class="computeroutput"><span class="identifier">endian_aware_structure</span></code>
+ can not be used without converting to native types, as <code class="computeroutput"><span class="identifier">endian_pack</span></code>
+ doesn't provide other operations than conversion.
       </p>
 <pre class="programlisting"><span class="identifier">endian_aware_structure</span> <span class="identifier">st</span><span class="special">;</span>
 <span class="comment">// ...
@@ -226,7 +227,7 @@
         applications would benefit from the safe and transparent approach.
       </p>
 <a name="toward_boost_integer_endian.overview.motivation.in_place_conversion"></a><h5>
-<a name="id2903770"></a>
+<a name="id3363428"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.in_place_conversion">In-place
         conversion</a>
       </h5>
@@ -245,17 +246,17 @@
 <span class="identifier">as_endian</span><span class="special">&lt;</span><span class="identifier">native</span><span class="special">&gt;(</span><span class="identifier">st</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">as_endian</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">&gt;(</span><span class="identifier">st</span><span class="special">);</span>
 </pre>
 <p>
- The fact that some context need this in-place conversion doesn't mean that
+ The fact that some contexts need this in-place conversion doesn't mean that
         every application should use this approach.
       </p>
 <a name="toward_boost_integer_endian.overview.motivation.udt_endianness"></a><h5>
-<a name="id2903930"></a>
+<a name="id3363589"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.udt_endianness">UDT
         endianness</a>
       </h5>
 <p>
- boost::integer::endian class didn't accept a UDT. We have updated the library
- so now UDT can be used for endian aligned types.
+ <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integer</span><span class="special">::</span><span class="identifier">endian</span></code> class didn't accept a UDT. We have
+ updated the library so now UDT can be used for endian aligned types.
       </p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">UserMessage</span> <span class="special">{</span>
   <span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">system_clock</span><span class="special">::</span><span class="identifier">time_point</span> <span class="special">&gt;</span> <span class="identifier">timestamp</span><span class="special">;</span>
@@ -273,7 +274,7 @@
 <span class="special">};</span> <span class="comment">// UserMessage
 </span></pre>
 <a name="toward_boost_integer_endian.overview.motivation.mixed_endianness"></a><h5>
-<a name="id2904560"></a>
+<a name="id3364243"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.mixed_endianness">Mixed
         endianness</a>
       </h5>
@@ -295,16 +296,17 @@
 <span class="special">};</span> <span class="comment">// Packet
 </span></pre>
 <a name="toward_boost_integer_endian.overview.motivation.floating_point"></a><h5>
-<a name="id2904737"></a>
+<a name="id3364420"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.floating_point">Floating
         point</a>
       </h5>
 <p>
         From my understanding floating point types are not only concerned by endianness,
- but also by a multitude of standard on not standard formats.
+ but also by a multitude of standard on not standard formats. The library
+ doent't manage with these standards.
       </p>
 <a name="toward_boost_integer_endian.overview.motivation.conclusion"></a><h5>
-<a name="id2904762"></a>
+<a name="id3364447"></a>
         <a class="link" href="overview.html#toward_boost_integer_endian.overview.motivation.conclusion">Conclusion</a>
       </h5>
 <p>

Modified: sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/reference.html
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/reference.html (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/reference.html 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -96,10 +96,10 @@
         Template <code class="computeroutput"><span class="identifier">to</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.from">Class
         Template <code class="computeroutput"><span class="identifier">from</span><span class="special">&lt;&gt;</span></code></a></span></dt>
-<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_to">Class
- Template <code class="computeroutput"><span class="identifier">is_to</span><span class="special">&lt;&gt;</span></code></a></span></dt>
-<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_from">Class
- Template <code class="computeroutput"><span class="identifier">is_from</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_target">Class
+ Template <code class="computeroutput"><span class="identifier">is_target</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_source">Class
+ Template <code class="computeroutput"><span class="identifier">is_source</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.convert">Non-Member
         Function Template <code class="computeroutput"><span class="identifier">convert</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 </dl></dd>
@@ -116,7 +116,7 @@
         and std::string types.
       </p>
 <a name="toward_boost_integer_endian.reference.binary_stream_hpp.synopsis"></a><h5>
-<a name="id2914045"></a>
+<a name="id3374710"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.binary_stream_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
@@ -235,10 +235,11 @@
         tags.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endianness_hpp.synopsis"></a><h5>
-<a name="id2917200"></a>
+<a name="id3377948"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endianness_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">integer</span> <span class="special">{</span>
     <span class="keyword">namespace</span> <span class="identifier">endianness</span> <span class="special">{</span>
         <span class="keyword">struct</span> <span class="identifier">big</span><span class="special">;</span>
         <span class="keyword">struct</span> <span class="identifier">little</span><span class="special">;</span>
@@ -247,6 +248,7 @@
         <span class="keyword">typedef</span> <span class="special">&lt;</span><span class="identifier">platform</span> <span class="identifier">dependent</span><span class="special">&gt;</span> <span class="identifier">native</span> <span class="special">;</span>
     <span class="special">}</span>
 <span class="special">}</span>
+<span class="special">}</span>
 </pre>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -316,7 +318,7 @@
         metafunction.
       </p>
 <a name="toward_boost_integer_endian.reference.endian_domain_map_hpp.synopsis"></a><h5>
-<a name="id2917763"></a>
+<a name="id3378533"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.endian_domain_map_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -335,28 +337,24 @@
     <span class="keyword">typedef</span> <span class="special">&lt;</span><span class="identifier">see</span> <span class="identifier">below</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-<p class="simpara">
- <span class="bold"><strong>Requires:</strong></span>
- </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem">
- <code class="computeroutput"><span class="identifier">Domain</span></code> any class.
- Can be also <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code>
- or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
- </li></ul></div>
-</li>
-<li class="listitem">
- <span class="bold"><strong>Result:</strong></span> The member typedef <code class="computeroutput"><span class="identifier">type</span></code> names a mpl tree of sequence
- of <code class="computeroutput"><span class="identifier">endianness</span></code> types
- as view from the point of view of the <code class="computeroutput"><span class="identifier">Domain</span></code>.
- The default definition is a mpl tree having as leaves the <code class="computeroutput"><span class="identifier">Domain</span></code> class for <code class="computeroutput"><span class="identifier">T</span></code>
- fundamental types, and fusion sequences.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Example:</strong></span>
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Requires:</strong></span>
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+ <code class="computeroutput"><span class="identifier">Domain</span></code> any class. Can
+ be also <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code>
+ or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
+ </li></ul></div>
+<p>
+ <span class="bold"><strong>Result:</strong></span> The member typedef <code class="computeroutput"><span class="identifier">type</span></code> names a mpl tree of sequence of
+ <code class="computeroutput"><span class="identifier">endianness</span></code> types as view
+ from the point of view of the <code class="computeroutput"><span class="identifier">Domain</span></code>.
+ The default definition is a mpl tree having as leaves the <code class="computeroutput"><span class="identifier">Domain</span></code> class for <code class="computeroutput"><span class="identifier">T</span></code>
+ fundamental types, and fusion sequences.
+ </p>
+<p>
+ <span class="bold"><strong>Example:</strong></span>
+ </p>
 <pre class="programlisting"><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">domain_map</span><span class="special">&lt;</span><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">==</span> <span class="keyword">true</span>
 
 <span class="keyword">struct</span> <span class="identifier">ifA</span> <span class="special">{};</span>
@@ -396,7 +394,7 @@
         configurations.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.synopsis"></a><h5>
-<a name="id2918396"></a>
+<a name="id3379153"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -469,40 +467,38 @@
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">native</span><span class="special">,</span> <span class="identifier">uint_least64_t</span><span class="special">,</span> <span class="number">56</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">unaligned</span> <span class="special">&gt;</span> <span class="identifier">unative56_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">native</span><span class="special">,</span> <span class="identifier">uint_least64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">unaligned</span> <span class="special">&gt;</span> <span class="identifier">unative64_pt</span><span class="special">;</span>
 
-<span class="preprocessor">#define</span> <span class="identifier">BOOST_HAS_INT16_T</span>
-<span class="preprocessor">#define</span> <span class="identifier">BOOST_HAS_INT32_T</span>
-<span class="preprocessor">#define</span> <span class="identifier">BOOST_HAS_INT64_T</span>
   
- <span class="comment">// These types only present if platform has exact size integers:
-</span> <span class="comment">// aligned big endian_pack signed integer types
-</span> <span class="comment">// aligned big endian_pack unsigned integer types
-</span> <span class="comment">// aligned little endian_pack signed integer types
-</span> <span class="comment">// aligned little endian_pack unsigned integer types
+ <span class="comment">// These types only present if platform has exact size integers:
+</span> <span class="comment">// aligned big endian_pack signed integer types
+</span> <span class="comment">// aligned big endian_pack unsigned integer types
+</span> <span class="comment">// aligned little endian_pack signed integer types
+</span> <span class="comment">// aligned little endian_pack unsigned integer types
 </span>
- <span class="comment">// aligned native endian_pack typedefs are not provided because
-</span> <span class="comment">// &lt;cstdint&gt; types are superior for this use case
-</span>
-<span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT16_T</span><span class="special">)</span>
+
+ <span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT16_T</span><span class="special">)</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">int16_t</span><span class="special">,</span> <span class="number">16</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_big16_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">uint16_t</span><span class="special">,</span> <span class="number">16</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ubig16_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">int16_t</span><span class="special">,</span> <span class="number">16</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_little16_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">uint16_t</span><span class="special">,</span> <span class="number">16</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ulittle16_pt</span><span class="special">;</span>
-<span class="preprocessor"># endif</span>
+ <span class="preprocessor"># endif</span>
 
-<span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT32_T</span><span class="special">)</span>
+ <span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT32_T</span><span class="special">)</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">int32_t</span><span class="special">,</span> <span class="number">32</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_big32_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">uint32_t</span><span class="special">,</span> <span class="number">32</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ubig32_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">int32_t</span><span class="special">,</span> <span class="number">32</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_little32_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">uint32_t</span><span class="special">,</span> <span class="number">32</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ulittle32_pt</span><span class="special">;</span>
-<span class="preprocessor"># endif</span>
+ <span class="preprocessor"># endif</span>
 
-<span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT64_T</span><span class="special">)</span>
+ <span class="preprocessor"># if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_HAS_INT64_T</span><span class="special">)</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">int64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_big64_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">uint64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ubig64_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">int64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_little64_pt</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian_pack</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">uint64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ulittle64_pt</span><span class="special">;</span>
-<span class="preprocessor"># endif</span>
+ <span class="preprocessor"># endif</span>
 
+ <span class="comment">// aligned native endian_pack typedefs are not provided because
+</span> <span class="comment">// &lt;cstdint&gt; types are superior for this use case
+</span>
 <span class="special">}</span>
 <span class="special">}</span>
 </pre>
@@ -527,89 +523,96 @@
           An <code class="computeroutput"><span class="identifier">endian_pack</span></code> is a byte-holder
           with user-specified endianness, value type, size, and alignment.
         </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span>
- <span class="keyword">typename</span> <span class="identifier">E</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">n_bits</span><span class="special">=</span><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">),</span>
- <span class="identifier">alignment</span> <span class="identifier">A</span> <span class="special">=</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">endian_pack</span> <span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
+<pre class="programlisting"> <span class="keyword">template</span> <span class="special">&lt;</span>
+ <span class="keyword">typename</span> <span class="identifier">E</span><span class="special">,</span>
+ <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">n_bits</span><span class="special">=</span><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">),</span>
+ <span class="identifier">alignment</span> <span class="identifier">A</span> <span class="special">=</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">endian_pack</span> <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">typedef</span> <span class="identifier">E</span> <span class="identifier">endian_type</span><span class="special">;</span>
- <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">width</span> <span class="special">=</span> <span class="identifier">n_bits</span><span class="special">;</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">alignment</span> <span class="identifier">alignment_value</span> <span class="special">=</span> <span class="identifier">A</span><span class="special">;</span>
-
+ <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">width</span> <span class="special">=</span> <span class="identifier">n_bits</span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">alignment</span> <span class="identifier">alignment_value</span> <span class="special">=</span> <span class="identifier">A</span><span class="special">;</span>
+
+<span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_ENDIAN_NO_CTORS</span>
   <span class="identifier">endian_pack</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span> <span class="comment">// = default replaced by {} on C++03
-</span> <span class="keyword">explicit</span> <span class="identifier">endian_pack</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
- <span class="identifier">endian_pack</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
- <span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
- <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
-<span class="special">};</span>
+</span> <span class="keyword">explicit</span> <span class="identifier">endian_pack</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
+<span class="preprocessor">#endif</span>
+ <span class="identifier">endian_pack</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
+ <span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+ <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+ <span class="special">};</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-<p class="simpara">
- <span class="bold"><strong>Requires:</strong></span>
- </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<p>
+ <span class="bold"><strong>Requires:</strong></span>
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">E</span></code> is one of <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code> or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
- </li>
+ <code class="computeroutput"><span class="identifier">E</span></code> is one of <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code> or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
+ </li>
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">T</span></code> must be a POD
- with value semantics.
- </li>
+ <code class="computeroutput"><span class="identifier">T</span></code> must be a POD with
+ value semantics.
+ </li>
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">nbits</span></code> is a multiple
- of <code class="computeroutput"><span class="number">8</span></code>
- </li>
+ <code class="computeroutput"><span class="identifier">nbits</span></code> is a multiple
+ of <code class="computeroutput"><span class="number">8</span></code>
+ </li>
 <li class="listitem">
- If <code class="computeroutput"><span class="identifier">A</span></code> is <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span></code> then <code class="computeroutput"><span class="identifier">nbits</span></code>
- must be equal to <code class="computeroutput"><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>
- </li>
+ If <code class="computeroutput"><span class="identifier">A</span></code> is <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span></code> then <code class="computeroutput"><span class="identifier">nbits</span></code>
+ must be equal to <code class="computeroutput"><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>
+ </li>
 </ul></div>
-</li></ul></div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endian"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endian" title="Default Contructor endian_pack()">Default
+ Contructor <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">()</span></code></a>
+</h5></div></div></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"><p>
- if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are not
- available then these two constructors will not be present
- </p></td></tr>
+ if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are
+ not available then this constructor will not be present
+ </p></td></tr>
 </table></div>
-<div class="section">
-<div class="titlepage"><div><div><h5 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endian"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endian" title="Default Contructor endian_pack()">Default
- Contructor <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">()</span></code></a>
-</h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian_pack</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span> <span class="comment">// C++03: endian(){}
 </span></pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of
- type <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span>
- <span class="identifier">A</span><span class="special">&gt;</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Effects:</strong></span> Constructs an object of type
+ <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
 <a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endianT"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian_pack.endianT" title="Contructor from value_type endian_pack(T)">Contructor
           from value_type <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code></a>
 </h5></div></div></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"><p>
+ if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are
+ not available then this constructor will not be present.
+ </p></td></tr>
+</table></div>
 <pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">endian_pack</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of
- type <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
- <span class="special">==</span> <span class="identifier">v</span></code>,
- where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
- object.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Effects:</strong></span> Constructs an object of type
+ <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
+ </p>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
+ <span class="special">==</span> <span class="identifier">v</span></code>,
+ where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
+ object.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -618,17 +621,12 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
- <span class="special">==</span> <span class="identifier">v</span></code>,
- where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
- object.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
+ <span class="special">==</span> <span class="identifier">v</span></code>,
+ where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
+ object. <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -637,11 +635,11 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> The current value stored
- in <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
- converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> The current value stored in
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
+ converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -650,11 +648,11 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> The current value stored
- in <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
- converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> The current value stored in
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
+ converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
+ </p>
 </div>
 </div>
 <div class="section"><div class="titlepage"><div><div><h4 class="title">
@@ -694,7 +692,7 @@
         names for common configurations.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_hpp.synopsis"></a><h5>
-<a name="id2925674"></a>
+<a name="id3386379"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -786,7 +784,6 @@
     <span class="keyword">typedef</span> <span class="identifier">endian</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">uint32_t</span><span class="special">,</span> <span class="number">32</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ulittle4_t</span><span class="special">;</span>
     <span class="keyword">typedef</span> <span class="identifier">endian</span><span class="special">&lt;</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">uint64_t</span><span class="special">,</span> <span class="number">64</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span> <span class="special">&gt;</span> <span class="identifier">aligned_ulittle8_t</span><span class="special">;</span>
 
-
     <span class="comment">// aligned native endian typedefs are not provided because
 </span> <span class="comment">// &lt;cstdint&gt; types are superior for this use case
 </span>
@@ -821,85 +818,89 @@
     <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">n_bits</span><span class="special">=</span><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">),</span>
     <span class="identifier">alignment</span> <span class="identifier">A</span> <span class="special">=</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">endian</span> <span class="special">:</span> <span class="identifier">integer_cover_operators</span><span class="special">&lt;</span> <span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">{</span>
+<span class="keyword">class</span> <span class="identifier">endian</span> <span class="special">:</span> <span class="identifier">cover_operators</span><span class="special">&lt;</span> <span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;,</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">typedef</span> <span class="identifier">E</span> <span class="identifier">endian_type</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
   <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">width</span> <span class="special">=</span> <span class="identifier">n_bits</span><span class="special">;</span>
   <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">alignment</span> <span class="identifier">alignment_value</span> <span class="special">=</span> <span class="identifier">A</span><span class="special">;</span>
   
+ <span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_ENDIAN_NO_CTORS</span>
   <span class="identifier">endian</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span> <span class="comment">// = default replaced by {} on C++03
 </span> <span class="keyword">explicit</span> <span class="identifier">endian</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
+ <span class="preprocessor">#endif</span>
   <span class="identifier">endian</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
   <span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-<p class="simpara">
- <span class="bold"><strong>Requires:</strong></span>
- </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<p>
+ <span class="bold"><strong>Requires:</strong></span>
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">E</span></code> is one of <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code> or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
- </li>
+ <code class="computeroutput"><span class="identifier">E</span></code> is one of <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span></code> or <code class="computeroutput"><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span></code>.
+ </li>
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">T</span></code> must be a POD
- with value semantics.
- </li>
+ <code class="computeroutput"><span class="identifier">T</span></code> must be a POD with
+ value semantics.
+ </li>
 <li class="listitem">
- <code class="computeroutput"><span class="identifier">nbits</span></code> is a multiple
- of <code class="computeroutput"><span class="number">8</span></code>
- </li>
+ <code class="computeroutput"><span class="identifier">nbits</span></code> is a multiple
+ of <code class="computeroutput"><span class="number">8</span></code>
+ </li>
 <li class="listitem">
- If <code class="computeroutput"><span class="identifier">A</span></code> is <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span></code> then <code class="computeroutput"><span class="identifier">nbits</span></code>
- must be equal to <code class="computeroutput"><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>
- </li>
+ If <code class="computeroutput"><span class="identifier">A</span></code> is <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span></code> then <code class="computeroutput"><span class="identifier">nbits</span></code>
+ must be equal to <code class="computeroutput"><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>
+ </li>
 </ul></div>
-</li></ul></div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_hpp.endian.endian"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_hpp.endian.endian" title="Default Contructor endian()">Default
+ Contructor <code class="computeroutput"><span class="identifier">endian</span><span class="special">()</span></code></a>
+</h5></div></div></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"><p>
- if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are not
- available then these two constructors will not be present
- </p></td></tr>
+ if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are
+ not available then this constructor will not be present
+ </p></td></tr>
 </table></div>
-<div class="section">
-<div class="titlepage"><div><div><h5 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_hpp.endian.endian"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_hpp.endian.endian" title="Default Contructor endian()">Default
- Contructor <code class="computeroutput"><span class="identifier">endian</span><span class="special">()</span></code></a>
-</h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span> <span class="comment">// C++03: endian(){}
 </span></pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of
- type <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span>
- <span class="identifier">A</span><span class="special">&gt;</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Effects:</strong></span> Constructs an object of type
+ <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
 <a name="toward_boost_integer_endian.reference.integer_endian_hpp.endian.endianT"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_hpp.endian.endianT" title="Contructor from value_type endian(T)">Contructor
           from value_type <code class="computeroutput"><span class="identifier">endian</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code></a>
 </h5></div></div></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"><p>
+ if BOOST_ENDIAN_FORCE_PODNESS is defined &amp;&amp; C++0x POD's are
+ not available then this constructor will not be present
+ </p></td></tr>
+</table></div>
 <pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">endian</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of
- type <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span>
- <span class="identifier">A</span><span class="special">&gt;</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
- <span class="special">==</span> <span class="identifier">v</span></code>,
- where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
- object.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Effects:</strong></span> Constructs an object of type
+ <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">x</span>
+ <span class="special">==</span> <span class="identifier">v</span></code>,
+ where <code class="computeroutput"><span class="identifier">x</span></code> is the constructed
+ object.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -908,14 +909,10 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">v</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">v</span></code>. <span class="bold"><strong>Returns:</strong></span>
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -924,11 +921,11 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> The current value stored
- in <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
- converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> The current value stored in
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
+ converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -937,11 +934,11 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> The current value stored
- in <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
- converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> The current value stored in
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
+ converted to <code class="computeroutput"><span class="identifier">value_type</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -971,7 +968,7 @@
         and extraction of endian types.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_binary_stream_hpp.synopsis"></a><h5>
-<a name="id2932802"></a>
+<a name="id3393485"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_binary_stream_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
@@ -1004,7 +1001,7 @@
 <div class="toc"><dl><dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_type_hpp.integer_endian_type">Meta
         Function <code class="computeroutput"><span class="identifier">endian_type</span><span class="special">&lt;&gt;</span></code></a></span></dt></dl></div>
 <a name="toward_boost_integer_endian.reference.integer_endian_type_hpp.synopsis"></a><h5>
-<a name="id2933768"></a>
+<a name="id3394450"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_type_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -1039,7 +1036,7 @@
           The user can specialize this metafunction for specific clases.
         </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_type_hpp.integer_endian_type.example"></a><h6>
-<a name="id2934086"></a>
+<a name="id3394768"></a>
           <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_type_hpp.integer_endian_type.example">Example</a>
         </h6>
 <pre class="programlisting"><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">endian_type</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">==</span> <span class="keyword">true</span>
@@ -1063,7 +1060,7 @@
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement">Assignement
           <code class="computeroutput"><span class="keyword">operator</span> <span class="special">=(</span><span class="identifier">endian_view</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2">Assignement
- from different endianness<code class="computeroutput"><span class="keyword">operator</span>
+ from different endianness <code class="computeroutput"><span class="keyword">operator</span>
           <span class="special">=(</span><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">Endian2</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span>
           <span class="keyword">const</span><span class="special">&amp;</span>
           <span class="special">)</span></code></a></span></dt>
@@ -1084,7 +1081,7 @@
         helper functions.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.synopsis"></a><h5>
-<a name="id2934391"></a>
+<a name="id3395073"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -1119,7 +1116,7 @@
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement">Assignement
           <code class="computeroutput"><span class="keyword">operator</span> <span class="special">=(</span><span class="identifier">endian_view</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2">Assignement
- from different endianness<code class="computeroutput"><span class="keyword">operator</span>
+ from different endianness <code class="computeroutput"><span class="keyword">operator</span>
           <span class="special">=(</span><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">Endian2</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span>
           <span class="keyword">const</span><span class="special">&amp;</span>
           <span class="special">)</span></code></a></span></dt>
@@ -1146,10 +1143,10 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian_view</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">&amp;</span> <span class="identifier">ref</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Effects:</strong></span> Constructs an object of
- type <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Effects:</strong></span> Constructs an object of type
+ <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">n_bits</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -1158,10 +1155,10 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="keyword">operator</span> <span class="identifier">value_type</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> The converted <code class="computeroutput"><span class="identifier">value_type</span></code> of the referenced type
- as it was seen as an endian aware type.
- </li></ul></div>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> The converted <code class="computeroutput"><span class="identifier">value_type</span></code> of the referenced type as
+ it was seen as an endian aware type.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -1170,20 +1167,16 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian_view</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">endian_view</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span>
- <span class="special">==</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">ref_</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span>
+ <span class="special">==</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">ref_</span></code>.
+ <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2" title="Assignement from different endiannessoperator =(endian_view&lt;Endian2,T&gt; const&amp; )">Assignement
- from different endianness<code class="computeroutput"><span class="keyword">operator</span>
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2" title="Assignement from different endianness operator =(endian_view&lt;Endian2,T&gt; const&amp; )">Assignement
+ from different endianness <code class="computeroutput"><span class="keyword">operator</span>
           <span class="special">=(</span><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">Endian2</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span>
           <span class="keyword">const</span><span class="special">&amp;</span>
           <span class="special">)</span></code></a>
@@ -1191,14 +1184,10 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian2</span> <span class="special">&gt;</span>
 <span class="identifier">endian_view</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">Endian2</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">value_type</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">ref_</span><span class="special">)</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">value_type</span><span class="special">(</span><span class="identifier">rhs</span><span class="special">.</span><span class="identifier">ref_</span><span class="special">)</span></code>.
+ <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
@@ -1207,14 +1196,10 @@
 </h5></div></div></div>
 <pre class="programlisting"><span class="identifier">endian_view</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">value_type</span> <span class="identifier">val</span><span class="special">);</span>
 </pre>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
- <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">v</span></code>.
- </li>
-<li class="listitem">
- <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
- </li>
-</ul></div>
+<p>
+ <span class="bold"><strong>Postcondition:</strong></span> <code class="computeroutput"><span class="identifier">value_type</span><span class="special">(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">ref_</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">v</span></code>. <span class="bold"><strong>Returns:</strong></span>
+ <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </p>
 </div>
 </div>
 <div class="section">
@@ -1225,6 +1210,11 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">E</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">as_endian</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> An <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code> that depend on the endianness parameter
+ <code class="computeroutput"><span class="identifier">E</span></code> referencing the pararameter
+ <code class="computeroutput"><span class="identifier">v</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1234,6 +1224,10 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">::</span><span class="identifier">native</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">as</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> A native endian <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code>
+ referencing the pararameter <code class="computeroutput"><span class="identifier">v</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1243,6 +1237,10 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">::</span><span class="identifier">little</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">as_little</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> A little endian <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code>
+ referencing the pararameter <code class="computeroutput"><span class="identifier">v</span></code>.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1252,6 +1250,9 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="identifier">endian_view</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">&lt;</span><span class="identifier">endian</span><span class="special">::</span><span class="identifier">big</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">as_big</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> A big endian <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code> referencing the pararameter <code class="computeroutput"><span class="identifier">v</span></code>.
+ </p>
 </div>
 </div>
 <div class="section">
@@ -1270,19 +1271,20 @@
         Template <code class="computeroutput"><span class="identifier">to</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.from">Class
         Template <code class="computeroutput"><span class="identifier">from</span><span class="special">&lt;&gt;</span></code></a></span></dt>
-<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_to">Class
- Template <code class="computeroutput"><span class="identifier">is_to</span><span class="special">&lt;&gt;</span></code></a></span></dt>
-<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_from">Class
- Template <code class="computeroutput"><span class="identifier">is_from</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_target">Class
+ Template <code class="computeroutput"><span class="identifier">is_target</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_source">Class
+ Template <code class="computeroutput"><span class="identifier">is_source</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.convert">Non-Member
         Function Template <code class="computeroutput"><span class="identifier">convert</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 </dl></div>
 <a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.synopsis"></a><h5>
-<a name="id2936924"></a>
+<a name="id3397708"></a>
         <a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.synopsis">Synopsis</a>
       </h5>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 <span class="keyword">namespace</span> <span class="identifier">integer</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">endianness</span> <span class="special">{</span>
 
     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">TargetDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">SourceDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
     <span class="keyword">void</span> <span class="identifier">convert_to_from</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
@@ -1295,14 +1297,15 @@
     
     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">to</span><span class="special">;</span>
     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">from</span><span class="special">;</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_to</span><span class="special">;</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_from</span><span class="special">;</span>
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_target</span><span class="special">;</span>
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_source</span><span class="special">;</span>
 
     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Endian2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
     <span class="keyword">void</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
     
 
-<span class="special">}</span> <span class="comment">// namespace integer
+<span class="special">}</span> <span class="comment">// namespace endianness
+</span><span class="special">}</span> <span class="comment">// namespace integer
 </span><span class="special">}</span> <span class="comment">// namespace boost
 </span></pre>
 <div class="section">
@@ -1313,6 +1316,10 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">TargetDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">SourceDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">convert_to_from</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> the conversion of <code class="computeroutput"><span class="identifier">v</span></code> viewed from <code class="computeroutput"><span class="identifier">SourceDomain</span></code>
+ to `TargetDomain'.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1322,6 +1329,10 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">SourceDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">convert_from</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> the conversion of <code class="computeroutput"><span class="identifier">v</span></code> viewed from <code class="computeroutput"><span class="identifier">SourceDomain</span></code>
+ to the native doamin.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1331,12 +1342,18 @@
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">TargetDomain</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">convert_to</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> the conversion of <code class="computeroutput"><span class="identifier">v</span></code> viewed from the native to `TargetDomain'.
+ </p>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.to"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.to" title="Class Template to&lt;&gt;">Class
         Template <code class="computeroutput"><span class="identifier">to</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
+<p>
+ Tag class used to signal target conversion.
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">to</span> <span class="special">{</span>
     <span class="keyword">typedef</span> <span class="identifier">Endian</span> <span class="identifier">type</span><span class="special">;</span>
@@ -1348,6 +1365,9 @@
 <a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.from"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.from" title="Class Template from&lt;&gt;">Class
         Template <code class="computeroutput"><span class="identifier">from</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
+<p>
+ Tag class used to signal source conversion.
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">from</span> <span class="special">{</span>
     <span class="keyword">typedef</span> <span class="identifier">Endian</span> <span class="identifier">type</span><span class="special">;</span>
@@ -1356,24 +1376,30 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_to"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_to" title="Class Template is_to&lt;&gt;">Class
- Template <code class="computeroutput"><span class="identifier">is_to</span><span class="special">&lt;&gt;</span></code></a>
+<a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_target"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_target" title="Class Template is_target&lt;&gt;">Class
+ Template <code class="computeroutput"><span class="identifier">is_target</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
+<p>
+ Template metafunction stating if the tag is a target domain.
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_to</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_target</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_to</span><span class="special">&lt;</span> <span class="identifier">to</span><span class="special">&lt;</span><span class="identifier">Endian</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_target</span><span class="special">&lt;</span> <span class="identifier">to</span><span class="special">&lt;</span><span class="identifier">Endian</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_from"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_from" title="Class Template is_from&lt;&gt;">Class
- Template <code class="computeroutput"><span class="identifier">is_from</span><span class="special">&lt;&gt;</span></code></a>
+<a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_source"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.is_source" title="Class Template is_source&lt;&gt;">Class
+ Template <code class="computeroutput"><span class="identifier">is_source</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
+<p>
+ Template metafunction stating if the tag is a source domain.
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_from</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_source</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">is_from</span><span class="special">&lt;</span> <span class="identifier">from</span><span class="special">&lt;</span><span class="identifier">Endian</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
+<span class="keyword">struct</span> <span class="identifier">is_source</span><span class="special">&lt;</span> <span class="identifier">from</span><span class="special">&lt;</span><span class="identifier">Endian</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section">
@@ -1381,9 +1407,18 @@
 <a name="toward_boost_integer_endian.reference.integer_endian_conversion_hpp.convert"></a><a class="link" href="reference.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.convert" title="Non-Member Function Template convert&lt;&gt;">Non-Member
         Function Template <code class="computeroutput"><span class="identifier">convert</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
+<p>
+ Coversion from source to target depending in the nature of the <code class="computeroutput"><span class="identifier">Endian1</span></code> and <code class="computeroutput"><span class="identifier">Endian2</span></code>
+ template parameters. One of them must be a target domain (<code class="computeroutput"><span class="identifier">to</span><span class="special">&lt;&gt;</span></code>)
+ and the other a source domain (<code class="computeroutput"><span class="identifier">from</span><span class="special">&lt;&gt;</span></code>).
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Endian1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Endian2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
 </pre>
+<p>
+ <span class="bold"><strong>Returns:</strong></span> the conversion of `v' viewed
+ from source domain to the target domain'.
+ </p>
 </div>
 </div>
 </div>

Modified: sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/users_guide.html
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/users_guide.html (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/html/toward_boost_integer_endian/users_guide.html 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -72,7 +72,7 @@
         <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span></a>
 </h4></div></div></div>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.getting__emphasis_role__bold__boost_integer_endian_ext__emphasis_"></a><h6>
-<a name="id2904986"></a>
+<a name="id3364670"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.getting__emphasis_role__bold__boost_integer_endian_ext__emphasis_">Getting
           <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span></a>
         </h6>
@@ -86,7 +86,7 @@
           Sandbox</a>.
         </p>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.building__emphasis_role__bold__boost_integer_endian_ext__emphasis_"></a><h6>
-<a name="id2905047"></a>
+<a name="id3364731"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.building__emphasis_role__bold__boost_integer_endian_ext__emphasis_">Building
           <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span></a>
         </h6>
@@ -112,7 +112,7 @@
             </li>
 </ul></div>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.requirements"></a><h6>
-<a name="id2905118"></a>
+<a name="id3364803"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.requirements">Requirements</a>
         </h6>
 <p>
@@ -134,7 +134,7 @@
 </dl>
 </div>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.exceptions_safety"></a><h6>
-<a name="id2905184"></a>
+<a name="id3364868"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.exceptions_safety">Exceptions
           safety</a>
         </h6>
@@ -143,7 +143,7 @@
           of exception safety as long as the underlying parameters provide it.
         </p>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.thread_safety"></a><h6>
-<a name="id2905212"></a>
+<a name="id3364896"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.thread_safety">Thread
           safety</a>
         </h6>
@@ -151,7 +151,7 @@
           All functions in the library are thread-unsafe except when noted explicitly.
         </p>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.tested_compilers"></a><h6>
-<a name="id2905238"></a>
+<a name="id3364922"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.install.tested_compilers">Tested
           compilers</a>
         </h6>
@@ -280,7 +280,7 @@
           will no longer be relying on unspecified behavior.
         </p>
 <a name="toward_boost_integer_endian.users_guide.getting_started.limitations_.binary_i_o_warnings_and_cautions"></a><h6>
-<a name="id2906050"></a>
+<a name="id3365734"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.getting_started.limitations_.binary_i_o_warnings_and_cautions">Binary
           I/O warnings and cautions</a>
         </h6>
@@ -333,8 +333,24 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types">Endian
         aware types</a></span></dt>
-<dd><dl><dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers">Endian
- aware integers</a></span></dt></dl></dd>
+<dd><dl>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic">basic
+ endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.streams">Binary
+ streams</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_pack">Endian
+ aware unaligned byte holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.typedefs">Endian
+ holders common typedefs</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.udt">Endian
+ holders of UDT</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.array">Arrays
+ of endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.struct">Structures
+ of endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers">Endian
+ aware integers</a></span></dt>
+</dl></dd>
 <dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types">Endian
         unaware types</a></span></dt>
 </dl></div>
@@ -343,39 +359,55 @@
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types" title="Endian aware types">Endian
         aware types</a>
 </h4></div></div></div>
-<div class="toc"><dl><dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers">Endian
- aware integers</a></span></dt></dl></div>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic_endian_holders"></a><h6>
-<a name="id2906357"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic_endian_holders">basic
+<div class="toc"><dl>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic">basic
+ endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.streams">Binary
+ streams</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_pack">Endian
+ aware unaligned byte holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.typedefs">Endian
+ holders common typedefs</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.udt">Endian
+ holders of UDT</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.array">Arrays
+ of endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.struct">Structures
+ of endian holders</a></span></dt>
+<dt><span class="section"><a href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers">Endian
+ aware integers</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic" title="basic endian holders">basic
           endian holders</a>
- </h6>
+</h5></div></div></div>
 <p>
- <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span> provides an endian
- aware byte-holder class template:
- </p>
+ <span class="bold"><strong>Boost.Integer.Endian.Ext</strong></span> provides an
+ endian aware byte-holder class template:
+ </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">endianness</span><span class="special">::</span><span class="identifier">enum_t</span> <span class="identifier">E</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">n_bytes</span><span class="special">=</span><span class="number">8</span><span class="special">*</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">),</span>
   <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">enum_t</span> <span class="identifier">A</span> <span class="special">=</span> <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned</span><span class="special">&gt;</span>
 <span class="keyword">class</span> <span class="identifier">endian_pack</span><span class="special">;</span>
 </pre>
 <p>
- This class provide portable byte-holders for data, independent of particular
- computer architectures. Use cases almost always involve I/O, either via
- files or network connections. Although data portability is the primary
- motivation, these byte-holders may also be used to reduce memory use, file
- size, or network activity since they provide binary integer sizes not otherwise
- available.
- </p>
-<p>
- Such byte-holder types are traditionally called endian types. See the Wikipedia
- for a full exploration of endianness, including definitions of big endian
- and little endian.
- </p>
-<p>
- This class doesn't provides arithmetic operators, but of course automatic
- conversion to and assignment from the underlying integer value type are
- provided.
- </p>
+ This class provide portable byte-holders for data, independent of particular
+ computer architectures. Use cases almost always involve I/O, either via
+ files or network connections. Although data portability is the primary
+ motivation, these byte-holders may also be used to reduce memory use,
+ file size, or network activity since they provide binary integer sizes
+ not otherwise available.
+ </p>
+<p>
+ Such byte-holder types are traditionally called endian types. See the
+ Wikipedia for a full exploration of endianness, including definitions
+ of big endian and little endian.
+ </p>
+<p>
+ This class doesn't provides arithmetic operators, but of course automatic
+ conversion to and assignment from the underlying integer value type are
+ provided.
+ </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 
@@ -397,26 +429,26 @@
 <span class="special">}</span>
 </pre>
 <p>
- On a little-endian CPU, this program outputs:
- </p>
+ On a little-endian CPU, this program outputs:
+ </p>
 <pre class="programlisting"><span class="number">825373492</span> <span class="number">825373492</span> <span class="number">825373492</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.binary_streams"></a><h6>
-<a name="id2906998"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.binary_streams">Binary
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.streams"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.streams" title="Binary streams">Binary
           streams</a>
- </h6>
+</h5></div></div></div>
 <p>
- Header &lt;boost/binary_stream.hpp&gt; provides operators <code class="computeroutput"><span class="special">&lt;=</span></code> and <code class="computeroutput"><span class="special">=&gt;</span></code>
- for unformatted binary (as opposed to formatted character) stream insertion
- and extraction of built-in and std::string types.
- </p>
+ Header &lt;boost/binary_stream.hpp&gt; provides operators <code class="computeroutput"><span class="special">&lt;=</span></code> and <code class="computeroutput"><span class="special">=&gt;</span></code>
+ for unformatted binary (as opposed to formatted character) stream insertion
+ and extraction of built-in and std::string types.
+ </p>
 <p>
- Header &lt;boost/integer/endian/endian_binary_stream.hpp&gt; provides operators
- <code class="computeroutput"><span class="special">&lt;=</span></code> and <code class="computeroutput"><span class="special">=&gt;</span></code>
- for unformatted binary (as opposed to formatted character) stream insertion
- and extraction of endian types.
- </p>
+ Header &lt;boost/integer/endian/endian_binary_stream.hpp&gt; provides
+ operators <code class="computeroutput"><span class="special">&lt;=</span></code> and <code class="computeroutput"><span class="special">=&gt;</span></code> for unformatted binary (as opposed
+ to formatted character) stream insertion and extraction of endian types.
+ </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
@@ -441,18 +473,19 @@
 <span class="special">}</span>
 </pre>
 <p>
- On a little-endian CPU, this program outputs:
- </p>
+ On a little-endian CPU, this program outputs:
+ </p>
 <pre class="programlisting"><span class="identifier">Hello</span><span class="special">,</span> <span class="identifier">endian</span> <span class="identifier">world</span><span class="special">!</span>
 
 <span class="number">825373492</span> <span class="number">825373492</span> <span class="number">825373492</span>
 <span class="number">4321</span> <span class="number">1234</span> <span class="number">4321</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_unaligned_byte_holders"></a><h6>
-<a name="id2907709"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_unaligned_byte_holders">endian
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_pack"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_pack" title="Endian aware unaligned byte holders">Endian
           aware unaligned byte holders</a>
- </h6>
+</h5></div></div></div>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 
@@ -475,20 +508,21 @@
 <span class="special">}</span>
 </pre>
 <p>
- On a little-endian CPU, this program outputs:
- </p>
+ On a little-endian CPU, this program outputs:
+ </p>
 <pre class="programlisting"><span class="number">3224115</span> <span class="number">3224115</span> <span class="number">3224115</span>
 <span class="number">123</span> <span class="number">321</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_common_typedefs"></a><h6>
-<a name="id2908268"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_common_typedefs">endian
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.typedefs"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.typedefs" title="Endian holders common typedefs">Endian
           holders common typedefs</a>
- </h6>
+</h5></div></div></div>
 <p>
- Sixty typedefs, such as big32_t, provide convenient naming conventions
- for common use cases:
- </p>
+ Sixty typedefs, such as big32_t, provide convenient naming conventions
+ for common use cases:
+ </p>
 <div class="informaltable"><table class="table">
 <colgroup>
 <col>
@@ -499,321 +533,321 @@
 </colgroup>
 <thead><tr>
 <th>
- <p>
- Name
- </p>
- </th>
+ <p>
+ Name
+ </p>
+ </th>
 <th>
- <p>
- Endianness
- </p>
- </th>
+ <p>
+ Endianness
+ </p>
+ </th>
 <th>
- <p>
- Sign
- </p>
- </th>
+ <p>
+ Sign
+ </p>
+ </th>
 <th>
- <p>
- Sizes in bits (n)
- </p>
- </th>
+ <p>
+ Sizes in bits (n)
+ </p>
+ </th>
 <th>
- <p>
- Alignment
- </p>
- </th>
+ <p>
+ Alignment
+ </p>
+ </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- signed
- </p>
- </td>
+ <p>
+ signed
+ </p>
+ </td>
 <td>
- <p>
- 8,16,24,32,40,48,56,64
- </p>
- </td>
+ <p>
+ 8,16,24,32,40,48,56,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unaligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unaligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">ubig</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">ubig</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- unsigned
- </p>
- </td>
+ <p>
+ unsigned
+ </p>
+ </td>
 <td>
- <p>
- 8,16,24,32,40,48,56,64
- </p>
- </td>
+ <p>
+ 8,16,24,32,40,48,56,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unaligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unaligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">little</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">little</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">little</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">little</span></code>
+ </p>
+ </td>
 <td>
- <p>
- signed
- </p>
- </td>
+ <p>
+ signed
+ </p>
+ </td>
 <td>
- <p>
- 8,16,24,32,40,48,56,64
- </p>
- </td>
+ <p>
+ 8,16,24,32,40,48,56,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unaligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unaligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">little</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">little</span></code>
+ </p>
+ </td>
 <td>
- <p>
- unsigned
- </p>
- </td>
+ <p>
+ unsigned
+ </p>
+ </td>
 <td>
- <p>
- 8,16,24,32,40,48,56,64
- </p>
- </td>
+ <p>
+ 8,16,24,32,40,48,56,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unaligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unaligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">native</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">native</span></code>
+ </p>
+ </td>
 <td>
- <p>
- signed
- </p>
- </td>
+ <p>
+ signed
+ </p>
+ </td>
 <td>
- <p>
- 8,16,24,32,40,48,56,64
- </p>
- </td>
+ <p>
+ 8,16,24,32,40,48,56,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unaligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unaligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">unative</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">unative</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">native</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">native</span></code>
+ </p>
+ </td>
 <td>
- <p>
- unsigned
- </p>
- </td>
+ <p>
+ unsigned
+ </p>
+ </td>
 <td>
- <p>
- 16,32,64
- </p>
- </td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_big</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_big</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- signed
- </p>
- </td>
+ <p>
+ signed
+ </p>
+ </td>
 <td>
- <p>
- 16,32,64
- </p>
- </td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_ubig</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_ubig</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- unsigned
- </p>
- </td>
+ <p>
+ unsigned
+ </p>
+ </td>
 <td>
- <p>
- 16,32,64
- </p>
- </td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_little</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_little</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- signed
- </p>
- </td>
+ <p>
+ signed
+ </p>
+ </td>
 <td>
- <p>
- 16,32,64
- </p>
- </td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
 </tr>
 <tr>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_ulittle</span></code><span class="bold"><strong>n</strong></span><code class="computeroutput"><span class="identifier">_t</span></code>
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">big</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">big</span></code>
+ </p>
+ </td>
 <td>
- <p>
- unsigned
- </p>
- </td>
+ <p>
+ unsigned
+ </p>
+ </td>
 <td>
- <p>
- 16,32,64
- </p>
- </td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
 <td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
 </tr>
 </tbody>
 </table></div>
 <p>
- The unaligned types do not cause compilers to insert padding bytes in classes
- and structs. This is an important characteristic that can be exploited
- to minimize wasted space in memory, files, and network transmissions.
- </p>
+ The unaligned types do not cause compilers to insert padding bytes in
+ classes and structs. This is an important characteristic that can be
+ exploited to minimize wasted space in memory, files, and network transmissions.
+ </p>
 <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"><p>
- Code that uses aligned types is inherently non-portable because alignment
- requirements vary between hardware architectures and because alignment
- may be affected by compiler switches or pragmas. Furthermore, aligned
- types are only available on architectures with 16, 32, and 64-bit integer
- types.
- </p></td></tr>
+ Code that uses aligned types is inherently non-portable because alignment
+ requirements vary between hardware architectures and because alignment
+ may be affected by compiler switches or pragmas. Furthermore, aligned
+ types are only available on architectures with 16, 32, and 64-bit integer
+ types.
+ </p></td></tr>
 </table></div>
 <div class="note"><table border="0" summary="Note">
 <tr>
@@ -821,27 +855,28 @@
 <th align="left">Note</th>
 </tr>
 <tr><td align="left" valign="top"><p>
- One-byte big-endian, little-endian, and native-endian types provide identical
- functionality. All three names are provided to improve code readability
- and searchability.
- </p></td></tr>
+ One-byte big-endian, little-endian, and native-endian types provide
+ identical functionality. All three names are provided to improve code
+ readability and searchability.
+ </p></td></tr>
 </table></div>
 <p>
- <span class="bold"><strong>Comment on naming</strong></span>
- </p>
+ <span class="bold"><strong>Comment on naming</strong></span>
+ </p>
 <p>
- When first exposed to endian types, programmers often fit them into a mental
- model based on the &lt;cstdint&gt; types. Using that model, it is natural
- to expect a 56-bit big-endian signed integer to be named <code class="computeroutput"><span class="identifier">int_big56_t</span></code>. But these byte-hodlers are
- not realy integers.
- </p>
+ When first exposed to endian types, programmers often fit them into a
+ mental model based on the &lt;cstdint&gt; types. Using that model, it
+ is natural to expect a 56-bit big-endian signed integer to be named
+ <code class="computeroutput"><span class="identifier">int_big56_t</span></code>. But these
+ byte-hodlers are not realy integers.
+ </p>
 <p>
- That seems to lead to formation of a new mental model specific to endian
- byte-holder types. In that model, the endianness is the key feature, and
- the integer aspect is downplayed. Once that mental transition is made,
- a name like <code class="computeroutput"><span class="identifier">big56_t</span></code> is
- a good reflection of the mental model.
- </p>
+ That seems to lead to formation of a new mental model specific to endian
+ byte-holder types. In that model, the endianness is the key feature,
+ and the integer aspect is downplayed. Once that mental transition is
+ made, a name like <code class="computeroutput"><span class="identifier">big56_t</span></code>
+ is a good reflection of the mental model.
+ </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
 
@@ -861,21 +896,22 @@
 <span class="special">}</span>
 </pre>
 <p>
- On a little-endian CPU, this program outputs:
- </p>
+ On a little-endian CPU, this program outputs:
+ </p>
 <pre class="programlisting"><span class="number">825373492</span> <span class="number">825373492</span> <span class="number">825373492</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_of_udt"></a><h6>
-<a name="id2909537"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_of_udt">endian
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.udt"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.udt" title="Endian holders of UDT">Endian
           holders of UDT</a>
- </h6>
+</h5></div></div></div>
 <p>
- The user can define wrappers to integer types that behave as integers,
- as it is the case for quantity&lt;&gt; class. This UDT can be packaged
- on an endian holder to take care of endian issues, as show the following
- example.
- </p>
+ The user can define wrappers to integer types that behave as integers,
+ as it is the case for quantity&lt;&gt; class. This UDT can be packaged
+ on an endian holder to take care of endian issues, as show the following
+ example.
+ </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
@@ -903,21 +939,22 @@
 <span class="special">}</span>
 </pre>
 <p>
- On a little-endian CPU, this program outputs:
- </p>
+ On a little-endian CPU, this program outputs:
+ </p>
 <pre class="programlisting"><span class="number">825373492</span> <span class="identifier">m</span> <span class="number">825373492</span> <span class="identifier">m</span> <span class="number">825373492</span> <span class="identifier">m</span>
 <span class="number">1234</span> <span class="number">4321</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.arrays_of_endian_holders"></a><h6>
-<a name="id2910556"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.arrays_of_endian_holders">Arrays
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.array"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.array" title="Arrays of endian holders">Arrays
           of endian holders</a>
- </h6>
+</h5></div></div></div>
 <p>
- Up to now we have see how to work with endian aware byte holders variables.
- In this section we will see how to work with arrays of endian aware byte
- holders.
- </p>
+ Up to now we have see how to work with endian aware byte holders variables.
+ In this section we will see how to work with arrays of endian aware byte
+ holders.
+ </p>
 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">endian</span><span class="special">/</span><span class="identifier">endian_binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">binary_stream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
@@ -940,11 +977,12 @@
     <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.structures_of_endian_holders"></a><h6>
-<a name="id2911174"></a>
- <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.structures_of_endian_holders">Structures
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.struct"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.struct" title="Structures of endian holders">Structures
           of endian holders</a>
- </h6>
+</h5></div></div></div>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">UdpHeader</span> <span class="special">{</span>
     <span class="identifier">ubig16_pt</span> <span class="identifier">source_port</span><span class="special">;</span>
     <span class="identifier">ubig16_pt</span> <span class="identifier">destination_port</span><span class="special">;</span>
@@ -958,6 +996,7 @@
 <span class="identifier">header</span><span class="special">.</span><span class="identifier">length</span> <span class="special">=</span> <span class="identifier">get_length</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
 <span class="identifier">header</span><span class="special">.</span><span class="identifier">checksum</span> <span class="special">=</span> <span class="identifier">checksum_of</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
 </pre>
+</div>
 <div class="section">
 <div class="titlepage"><div><div><h5 class="title">
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers" title="Endian aware integers">Endian
@@ -999,7 +1038,7 @@
             Automatic conversion is provided to the underlying integer value type.
           </p>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers.typedefs"></a><h6>
-<a name="id2911904"></a>
+<a name="id3371572"></a>
             <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers.typedefs">Typedefs</a>
           </h6>
 <p>
@@ -1315,7 +1354,7 @@
 </tbody>
 </table></div>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers.comment_on_naming"></a><h6>
-<a name="id2912749"></a>
+<a name="id3372417"></a>
             <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_integers.comment_on_naming">Comment
             on naming</a>
           </h6>
@@ -1340,18 +1379,104 @@
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types"></a><a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types" title="Endian unaware types">Endian
         unaware types</a>
 </h4></div></div></div>
+<p>
+ Endian unaware types don't track the endiannes of the stored data. For
+ example
+ </p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">X</span> <span class="special">{</span>
+
+<span class="keyword">struct</span> <span class="identifier">big_c</span> <span class="special">{</span>
+ <span class="identifier">uint32_t</span> <span class="identifier">a</span><span class="special">;</span>
+ <span class="identifier">uint16_t</span> <span class="identifier">b</span><span class="special">;</span>
+<span class="special">};</span>
+
+
+<span class="keyword">struct</span> <span class="identifier">little_c</span> <span class="special">{</span>
+ <span class="identifier">int32_t</span> <span class="identifier">a</span><span class="special">;</span>
+ <span class="identifier">int16_t</span> <span class="identifier">b</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">struct</span> <span class="identifier">mixed_c</span> <span class="special">{</span>
+ <span class="identifier">big_c</span> <span class="identifier">a</span><span class="special">;</span>
+ <span class="identifier">little_c</span> <span class="identifier">b</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="special">}</span>
+</pre>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.working_with_third_party_structures"></a><h6>
-<a name="id2912827"></a>
+<a name="id3372675"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.working_with_third_party_structures">Working
           with third party structures</a>
         </h6>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.domain_map"></a><h6>
-<a name="id2912850"></a>
+<a name="id3372699"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.domain_map">Domain
           map</a>
         </h6>
+<p>
+ When we need to send the mixed_c structure through the network we need
+ to state the endiannes of each one of the fields, so the library is able
+ to make the adequated conversions. This is done using the domain_map metafunction,
+ as follows:
+ </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">network</span> <span class="special">{};</span>
+
+<span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">integer</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">endianness</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
+ <span class="keyword">struct</span> <span class="identifier">domain_map</span> <span class="special">&lt;</span><span class="identifier">network</span><span class="special">,</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">big_c</span><span class="special">&gt;</span> <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">,</span><span class="identifier">big</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>
+ <span class="special">};</span>
+ <span class="keyword">template</span> <span class="special">&lt;&gt;</span>
+ <span class="keyword">struct</span> <span class="identifier">domain_map</span> <span class="special">&lt;</span><span class="identifier">network</span><span class="special">,</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">little_c</span><span class="special">&gt;</span> <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">little</span><span class="special">,</span><span class="identifier">little</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>
+ <span class="special">};</span>
+
+<span class="special">}</span>
+<span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<p>
+ In addition we need to see the types as fusion sequence so we can visit
+ them in a homogeneous way.
+ </p>
+<pre class="programlisting"><span class="identifier">BOOST_FUSION_ADAPT_STRUCT</span><span class="special">(</span>
+ <span class="identifier">X</span><span class="special">::</span><span class="identifier">big_c</span><span class="special">,</span>
+ <span class="special">(</span><span class="identifier">uint32_t</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span>
+ <span class="special">(</span><span class="identifier">uint16_t</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span>
+<span class="special">)</span>
+
+<span class="identifier">BOOST_FUSION_ADAPT_STRUCT</span><span class="special">(</span>
+ <span class="identifier">X</span><span class="special">::</span><span class="identifier">little_c</span><span class="special">,</span>
+ <span class="special">(</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span>
+ <span class="special">(</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span>
+<span class="special">)</span>
+
+<span class="identifier">BOOST_FUSION_ADAPT_STRUCT</span><span class="special">(</span>
+ <span class="identifier">X</span><span class="special">::</span><span class="identifier">mixed_c</span><span class="special">,</span>
+ <span class="special">(</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">big_c</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span>
+ <span class="special">(</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">little_c</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span>
+<span class="special">)</span>
+</pre>
+<p>
+ Now we are able to make an in-place conversion as follows:
+ </p>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span> <span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">X</span><span class="special">::</span><span class="identifier">mixed_c</span> <span class="identifier">m</span><span class="special">;</span>
+ <span class="identifier">m</span><span class="special">.</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">a</span><span class="special">=</span><span class="number">0x01020304</span><span class="special">;</span>
+ <span class="identifier">m</span><span class="special">.</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">b</span><span class="special">=</span><span class="number">0x0A0B</span><span class="special">;</span>
+ <span class="identifier">m</span><span class="special">.</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">a</span><span class="special">=</span><span class="number">0x04030201</span><span class="special">;</span>
+ <span class="identifier">m</span><span class="special">.</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">b</span><span class="special">=</span><span class="number">0x0B0A</span><span class="special">;</span>
+
+ <span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">network</span><span class="special">&gt;(</span><span class="identifier">m</span><span class="special">);</span>
+ <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+<span class="special">}</span> <span class="comment">// main
+</span></pre>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.in_place_conversions"></a><h6>
-<a name="id2912872"></a>
+<a name="id3373535"></a>
           <a class="link" href="users_guide.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.in_place_conversions">In-place
           conversions</a>
         </h6>

Modified: sandbox/endian_ext/libs/integer/endian/doc/integer_endian.pdf
==============================================================================
Binary files. No diff available.

Modified: sandbox/endian_ext/libs/integer/endian/doc/integer_endian.qbk
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/doc/integer_endian.qbk (original)
+++ sandbox/endian_ext/libs/integer/endian/doc/integer_endian.qbk 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -7,7 +7,7 @@
  /]
 
 [article Toward Boost.Integer.Endian
- [quickbook 1.4]
+ [quickbook 1.5]
     [version 0.2.0]
     [authors [Dawes, Beman]]
     [authors [Botet Escriba, Vicente J.]]
@@ -79,10 +79,10 @@
 
 This endian aware design seems to be unappropiated to work with endian unaware types, but as we will see this is not completly true, as we can construct on top of the Beman's design endian unaware operation. Next follows some of the main critics that have been done recently.
 
-[heading Intrusive verus non-intrusive]
+[heading Intrusive versus non-intrusive]
 [/====================================]
 
-Endian conversion must be possible to any type even if you can't modify the original source code. Many people think that originel Beman's library requires the data types which need to be converted to be coded using his endian types as members.
+Endian conversion must be possible for any type even if you can't modify the original source code. Many people think that originel Beman's library requires the data types which need to be converted to be coded using his endian types as members.
 
 We will see that this is not true, as the user can always use casting to reinterpret a given structure on another one, as the proposed extension does with the endian_views.
 
@@ -101,7 +101,7 @@
 The typical use case is to use native endianness until ready to read/write using wire format. It is only when ready to do I/O that there is a need to account for endianness.
 
 Beman's original library requires two types one to specify the physical data and the other representing the logical data.
-Many people think that this means that the user has to maintain two separate structs/classes when only one is needed. This could be sometimes the case, but in other cases, the user will store the information elements include in the message on local variables and specific contexts that don't follow the external format.
+Many people think that this means that the user has to maintain two separate structs/classes when only one is needed. This could be sometimes the case, but in other cases, the user will store the information elements included in the message on local variables and specific contexts that don't follow the external format.
 
 Applications that don't separate the physical and the logical data structures don't scale well as any change on the external format will mean a refactoring of the whole application. Also, the wire structures cannot maintain invariants, so having a separate class is often useful even if its contents are essentially identical to the wire version.
 
@@ -122,7 +122,7 @@
     };
 
 
-Structure endian_aware_structure can not be used without converting to native types, as endian_pack don't provide other operations than conversion.
+Structure `endian_aware_structure` can not be used without converting to native types, as `endian_pack` doesn't provide other operations than conversion.
 
     endian_aware_structure st;
     // ...
@@ -144,13 +144,13 @@
    
     as_endian<native>(st) = as_endian<big>(st);
 
-The fact that some context need this in-place conversion doesn't mean that every application should use this approach.
+The fact that some contexts need this in-place conversion doesn't mean that every application should use this approach.
 
 
 [heading UDT endianness]
 [/=====================]
 
-boost::integer::endian class didn't accept a UDT. We have updated the library so now UDT can be used for endian aligned types.
+`boost::integer::endian` class didn't accept a UDT. We have updated the library so now UDT can be used for endian aligned types.
 
     struct UserMessage {
       endian_pack<little, system_clock::time_point > timestamp;
@@ -188,24 +188,16 @@
 
 
 
-[/A real-world use-case that uses multiple endians and has
-different protocol layers.
-That is one over-the-wire packet has several layers of headers, possibly
-with different endian alignment than the user payload contained. This is
-common on PC's which often have big-endian IP headers and then have a
-little-endian user payload. The whole packet is read in from a socket at
-once into a data buffer owned by a unique_ptr, so the message is not copied
-from layer-to-layer. I work on proprietary, non-internet networks, so I'm
-not sure which protocol headers we should use for a use-case. In my
-wireless applications, the headers are usually padded to an integral number
-of bytes, but fields within the headers are sometimes not byte-aligned.
+[/A real-world use-case that uses multiple endians and has different protocol layers.
+
+That is one over-the-wire packet has several layers of headers, possibly with different endian alignment than the user payload contained. This is common on PC's which often have big-endian IP headers and then have a little-endian user payload. The whole packet is read in from a socket at once into a data buffer owned by a `unique_ptr`, so the message is not copied from layer-to-layer. I work on proprietary, non-internet networks, so I'm not sure which protocol headers we should use for a use-case. In my wireless applications, the headers are usually padded to an integral number of bytes, but fields within the headers are sometimes not byte-aligned.
 ]
 
 
 [heading Floating point]
 [/====================================]
 
-From my understanding floating point types are not only concerned by endianness, but also by a multitude of standard on not standard formats.
+From my understanding floating point types are not only concerned by endianness, but also by a multitude of standard on not standard formats. The library doent't manage with these standards.
 
 [heading Conclusion]
 [/=================]
@@ -351,7 +343,6 @@
 [section Hello Endian World! ]
 [/=============================]
 
-
     #include <boost/integer/endian/endian.hpp>
     #include <boost/integer/endian/endian_binary_stream.hpp>
     #include <boost/binary_stream.hpp>
@@ -414,7 +405,7 @@
 [section Endian aware types]
 [/=========================]
 
-[heading basic endian holders]
+[section:basic basic endian holders]
 
 __Boost_Endian provides an endian aware byte-holder class template:
 
@@ -452,7 +443,9 @@
 
     825373492 825373492 825373492
 
-[heading Binary streams]
+[endsect]
+
+[section:streams Binary streams]
 
 Header <boost/binary_stream.hpp> provides operators `<=` and `=>` for unformatted binary (as opposed to formatted character) stream insertion and extraction of built-in and std::string types.
 
@@ -488,8 +481,9 @@
     825373492 825373492 825373492
     4321 1234 4321
 
+[endsect]
 
-[heading endian aware unaligned byte holders]
+[section:endian_pack Endian aware unaligned byte holders]
 
 
     #include <boost/integer/endian/endian_pack.hpp>
@@ -518,8 +512,9 @@
     3224115 3224115 3224115
     123 321
 
+[endsect]
 
-[heading endian holders common typedefs]
+[section:typedefs Endian holders common typedefs]
 
 
 Sixty typedefs, such as big32_t, provide convenient naming conventions for common use cases:
@@ -576,8 +571,9 @@
 
     825373492 825373492 825373492
     
+[endsect]
 
-[heading endian holders of UDT]
+[section:udt Endian holders of UDT]
 
 The user can define wrappers to integer types that behave as integers, as it is the case for
 quantity<> class. This UDT can be packaged on an endian holder to take care of endian issues, as show the following example.
@@ -613,7 +609,9 @@
     825373492 m 825373492 m 825373492 m
     1234 4321
 
-[heading Arrays of endian holders]
+[endsect]
+
+[section:array Arrays of endian holders]
 
 Up to now we have see how to work with endian aware byte holders variables. In this section we will see how to work with arrays of endian aware byte holders.
 
@@ -639,8 +637,9 @@
         return 0;
     }
 
+[endsect]
 
-[heading Structures of endian holders]
+[section:struct Structures of endian holders]
 
     struct UdpHeader {
         ubig16_pt source_port;
@@ -655,6 +654,7 @@
     header.length = get_length(p);
     header.checksum = checksum_of(p);
 
+[endsect]
 
 [/===========================]
 [section Endian aware integers]
@@ -707,11 +707,94 @@
 [section Endian unaware types]
 [/===========================]
 
+
+Endian unaware types don't track the endiannes of the stored data. For example
+
+ namespace X {
+
+ struct big_c {
+ uint32_t a;
+ uint16_t b;
+ };
+
+
+ struct little_c {
+ int32_t a;
+ int16_t b;
+ };
+
+ struct mixed_c {
+ big_c a;
+ little_c b;
+ };
+
+ }
+
+
 [heading Working with third party structures]
 
 
 [heading Domain map]
 
+When we need to send the mixed_c structure through the network we need to state the endiannes of each one of the fields, so the library is able to make the adequated conversions. This is done using the domain_map metafunction, as follows:
+
+
+ struct network {};
+
+ namespace boost {
+ namespace integer {
+ namespace endianness {
+
+ template <>
+ struct domain_map <network, X::big_c> {
+ typedef mpl::vector<big,big> type;
+ };
+ template <>
+ struct domain_map <network, X::little_c> {
+ typedef mpl::vector<little,little> type;
+ };
+
+ }
+ }
+ }
+
+In addition we need to see the types as fusion sequence so we can visit them in a homogeneous way.
+
+ BOOST_FUSION_ADAPT_STRUCT(
+ X::big_c,
+ (uint32_t, a)
+ (uint16_t, b)
+ )
+
+ BOOST_FUSION_ADAPT_STRUCT(
+ X::little_c,
+ (int32_t, a)
+ (int16_t, b)
+ )
+
+ BOOST_FUSION_ADAPT_STRUCT(
+ X::mixed_c,
+ (X::big_c, a)
+ (X::little_c, b)
+ )
+
+
+Now we are able to make an in-place conversion as follows:
+
+ int main( )
+ {
+ X::mixed_c m;
+ m.b.a=0x01020304;
+ m.b.b=0x0A0B;
+ m.a.a=0x04030201;
+ m.a.b=0x0B0A;
+
+ convert_to<network>(m);
+ return 0;
+ } // main
+
+
+
 [heading In-place conversions]
 
 [endsect]
@@ -956,6 +1039,7 @@
 [heading Synopsis]
 
     namespace boost {
+ namespace integer {
         namespace endianness {
             struct big;
             struct little;
@@ -964,6 +1048,7 @@
             typedef <platform dependent> native ;
         }
     }
+ }
 
 [/
         // scoped enum emulated on C++03
@@ -1055,13 +1140,13 @@
             typedef <see below> type;
         };
 
-* [*Requires:]
+[*Requires:]
 
- * `Domain` any class. Can be also `endianness::big` or `endianness::little`.
+* `Domain` any class. Can be also `endianness::big` or `endianness::little`.
 
-* [*Result:] The member typedef `type` names a mpl tree of sequence of `endianness` types as view from the point of view of the `Domain`. The default definition is a mpl tree having as leaves the `Domain` class for `T` fundamental types, and fusion sequences.
+[*Result:] The member typedef `type` names a mpl tree of sequence of `endianness` types as view from the point of view of the `Domain`. The default definition is a mpl tree having as leaves the `Domain` class for `T` fundamental types, and fusion sequences.
 
-* [*Example:]
+[*Example:]
 
     is_same<domain_map<endianness::big, int>::type, endianness::big>::value == true
 
@@ -1155,39 +1240,37 @@
         typedef endian_pack< endianness::native, uint_least64_t, 56, alignment::unaligned > unative56_pt;
         typedef endian_pack< endianness::native, uint_least64_t, 64, alignment::unaligned > unative64_pt;
 
- #define BOOST_HAS_INT16_T
- #define BOOST_HAS_INT32_T
- #define BOOST_HAS_INT64_T
       
- // These types only present if platform has exact size integers:
- // aligned big endian_pack signed integer types
- // aligned big endian_pack unsigned integer types
- // aligned little endian_pack signed integer types
- // aligned little endian_pack unsigned integer types
+ // These types only present if platform has exact size integers:
+ // aligned big endian_pack signed integer types
+ // aligned big endian_pack unsigned integer types
+ // aligned little endian_pack signed integer types
+ // aligned little endian_pack unsigned integer types
 
- // aligned native endian_pack typedefs are not provided because
- // <cstdint> types are superior for this use case
 
- # if defined(BOOST_HAS_INT16_T)
+ # if defined(BOOST_HAS_INT16_T)
         typedef endian_pack< endianness::big, int16_t, 16, alignment::aligned > aligned_big16_pt;
         typedef endian_pack< endianness::big, uint16_t, 16, alignment::aligned > aligned_ubig16_pt;
         typedef endian_pack< endianness::little, int16_t, 16, alignment::aligned > aligned_little16_pt;
         typedef endian_pack< endianness::little, uint16_t, 16, alignment::aligned > aligned_ulittle16_pt;
- # endif
+ # endif
 
- # if defined(BOOST_HAS_INT32_T)
+ # if defined(BOOST_HAS_INT32_T)
         typedef endian_pack< endianness::big, int32_t, 32, alignment::aligned > aligned_big32_pt;
         typedef endian_pack< endianness::big, uint32_t, 32, alignment::aligned > aligned_ubig32_pt;
         typedef endian_pack< endianness::little, int32_t, 32, alignment::aligned > aligned_little32_pt;
         typedef endian_pack< endianness::little, uint32_t, 32, alignment::aligned > aligned_ulittle32_pt;
- # endif
+ # endif
 
- # if defined(BOOST_HAS_INT64_T)
+ # if defined(BOOST_HAS_INT64_T)
         typedef endian_pack< endianness::big, int64_t, 64, alignment::aligned > aligned_big64_pt;
         typedef endian_pack< endianness::big, uint64_t, 64, alignment::aligned > aligned_ubig64_pt;
         typedef endian_pack< endianness::little, int64_t, 64, alignment::aligned > aligned_little64_pt;
         typedef endian_pack< endianness::little, uint64_t, 64, alignment::aligned > aligned_ulittle64_pt;
- # endif
+ # endif
+
+ // aligned native endian_pack typedefs are not provided because
+ // <cstdint> types are superior for this use case
 
     }
     }
@@ -1205,37 +1288,38 @@
             alignment A = alignment::aligned>
         class endian_pack {
         public:
- typedef E endian_type;
+ typedef E endian_type;
           typedef T value_type;
           static const std::size_t width = n_bits;
           static const alignment alignment_value = A;
           
- endian_pack() = default; // = default replaced by {} on C++03
+ #ifndef BOOST_ENDIAN_NO_CTORS
+ endian_pack() = default; // = default replaced by {} on C++03
           explicit endian_pack(T v);
+ #endif
           endian_pack & operator=(T v);
           operator T() const;
           const char* data() const;
         };
 
 
-* [*Requires:]
-
- * `E` is one of `endianness::big` or `endianness::little`.
- * `T` must be a POD with value semantics.
- * `nbits` is a multiple of `8`
- * If `A` is `alignment::aligned` then `nbits` must be equal to `8*sizeof(T)`
-
-[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
-available then these two constructors will not be present]
+[*Requires:]
 
+* `E` is one of `endianness::big` or `endianness::little`.
+* `T` must be a POD with value semantics.
+* `nbits` is a multiple of `8`
+* If `A` is `alignment::aligned` then `nbits` must be equal to `8*sizeof(T)`
 
 [/==========================================================================================]
 [section:endian Default Contructor `endian_pack()`]
 [/==========================================================================================]
 
+[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
+available then this constructor will not be present]
+
     endian_pack() = default; // C++03: endian(){}
 
-* [*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
+[*Effects:] Constructs an object of type `endian_pack<E, T, n_bits, A>`.
 
 [endsect]
 
@@ -1243,10 +1327,14 @@
 [section:endianT Contructor from value_type `endian_pack(T)`]
 [/==========================================================================================]
 
+[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
+available then this constructor will not be present.]
+
     explicit endian_pack(T v);
 
-* [*Effects:] Constructs an object of type `endian_pack<E, T, n_bits, A>`.
-* [*Postcondition:] `x == v`, where `x` is the constructed object.
+[*Effects:] Constructs an object of type `endian_pack<E, T, n_bits, A>`.
+
+[*Postcondition:] `x == v`, where `x` is the constructed object.
 
 [endsect]
 
@@ -1256,8 +1344,8 @@
 
     endian & operator=(T v);
 
-* [*Postcondition:] `x == v`, where `x` is the constructed object.
-* [*Returns:] `*this`.
+[*Postcondition:] `x == v`, where `x` is the constructed object.
+[*Returns:] `*this`.
 
 [endsect]
 
@@ -1267,7 +1355,7 @@
 
     operator T() const;
 
-* [*Returns:] The current value stored in `*this`, converted to `value_type`.
+[*Returns:] The current value stored in `*this`, converted to `value_type`.
 
 [endsect]
 
@@ -1277,7 +1365,7 @@
 
           const char* data() const;
 
-* [*Returns:] The current value stored in `*this`, converted to `value_type`.
+[*Returns:] The current value stored in `*this`, converted to `value_type`.
 
 [endsect]
 
@@ -1388,7 +1476,6 @@
         typedef endian< endianness::little, uint32_t, 32, alignment::aligned > aligned_ulittle4_t;
         typedef endian< endianness::little, uint64_t, 64, alignment::aligned > aligned_ulittle8_t;
 
-
         // aligned native endian typedefs are not provided because
         // <cstdint> types are superior for this use case
 
@@ -1408,38 +1495,40 @@
             typename T,
             std::size_t n_bits=8*sizeof(T),
             alignment A = alignment::aligned>
- class endian : integer_cover_operators< endian<E, T, n_bits, A>, T > {
+ class endian : cover_operators< endian<E, T, n_bits, A>, T > {
         public:
           typedef E endian_type;
           typedef T value_type;
           static const std::size_t width = n_bits;
           static const alignment alignment_value = A;
           
+ #ifndef BOOST_ENDIAN_NO_CTORS
           endian() = default; // = default replaced by {} on C++03
           explicit endian(T v);
+ #endif
           endian & operator=(T v);
           operator T() const;
           const char* data() const;
         };
 
-* [*Requires:]
-
- * `E` is one of `endianness::big` or `endianness::little`.
- * `T` must be a POD with value semantics.
- * `nbits` is a multiple of `8`
- * If `A` is `alignment::aligned` then `nbits` must be equal to `8*sizeof(T)`
+[*Requires:]
 
-[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
-available then these two constructors will not be present]
+* `E` is one of `endianness::big` or `endianness::little`.
+* `T` must be a POD with value semantics.
+* `nbits` is a multiple of `8`
+* If `A` is `alignment::aligned` then `nbits` must be equal to `8*sizeof(T)`
 
 
 [/==========================================================================================]
 [section:endian Default Contructor `endian()`]
 [/==========================================================================================]
 
+[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
+available then this constructor will not be present]
+
     endian() = default; // C++03: endian(){}
 
-* [*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
+[*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
 
 [endsect]
 
@@ -1447,10 +1536,13 @@
 [section:endianT Contructor from value_type `endian(T)`]
 [/==========================================================================================]
 
+[note if BOOST_ENDIAN_FORCE_PODNESS is defined && C++0x POD's are not
+available then this constructor will not be present]
+
     explicit endian(T v);
 
-* [*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
-* [*Postcondition:] `x == v`, where `x` is the constructed object.
+[*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
+[*Postcondition:] `x == v`, where `x` is the constructed object.
 
 [endsect]
 
@@ -1460,8 +1552,8 @@
 
     endian & operator=(T v);
 
-* [*Postcondition:] `value_type(*this) == v`.
-* [*Returns:] `*this`.
+[*Postcondition:] `value_type(*this) == v`.
+[*Returns:] `*this`.
 
 [endsect]
 
@@ -1471,7 +1563,7 @@
 
     operator T() const;
 
-* [*Returns:] The current value stored in `*this`, converted to `value_type`.
+[*Returns:] The current value stored in `*this`, converted to `value_type`.
 
 [endsect]
 
@@ -1481,7 +1573,7 @@
 
           const char* data() const;
 
-* [*Returns:] The current value stored in `*this`, converted to `value_type`.
+[*Returns:] The current value stored in `*this`, converted to `value_type`.
 
 [endsect]
 
@@ -1622,7 +1714,7 @@
 
             endian_view(value_type& ref);
 
-* [*Effects:] Constructs an object of type `endian_view<E, T, n_bits, A>`.
+[*Effects:] Constructs an object of type `endian_view<E, T, n_bits, A>`.
 
 [endsect]
 
@@ -1632,7 +1724,7 @@
 
             operator value_type() const;
 
-* [*Returns:] The converted `value_type` of the referenced type as it was seen as an endian aware type.
+[*Returns:] The converted `value_type` of the referenced type as it was seen as an endian aware type.
 
 [endsect]
 
@@ -1642,20 +1734,20 @@
 
             endian_view& operator=(endian_view const& rhs);
 
-* [*Postcondition:] `this->ref_ == rhs.ref_`.
-* [*Returns:] `*this`.
+[*Postcondition:] `this->ref_ == rhs.ref_`.
+[*Returns:] `*this`.
 
 [endsect]
 
 [/==========================================================================================]
-[section:assignement2 Assignement from different endianness`operator =(endian_view<Endian2,T> const& )`]
+[section:assignement2 Assignement from different endianness `operator =(endian_view<Endian2,T> const& )`]
 [/==========================================================================================]
 
             template <typename Endian2 >
             endian_view& operator=(endian_view<Endian2,T> const& rhs) {
 
-* [*Postcondition:] `value_type(this->ref_) == value_type(rhs.ref_)`.
-* [*Returns:] `*this`.
+[*Postcondition:] `value_type(this->ref_) == value_type(rhs.ref_)`.
+[*Returns:] `*this`.
 
 [endsect]
 
@@ -1666,8 +1758,8 @@
 
             endian_view& operator=(value_type val);
 
-* [*Postcondition:] `value_type(this->ref_) == v`.
-* [*Returns:] `*this`.
+[*Postcondition:] `value_type(this->ref_) == v`.
+[*Returns:] `*this`.
 
 [endsect]
 
@@ -1682,6 +1774,8 @@
         template <typename E, typename T>
         endian_view<endian<E,T> > as_endian(T& v);
 
+[*Returns:] An `endian_view<>` that depend on the endianness parameter `E` referencing the pararameter `v`.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1691,6 +1785,8 @@
         template <typename T>
         endian_view<endian<endian::native, T> > as(T& v);
 
+[*Returns:] A native endian `endian_view<>` referencing the pararameter `v`.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1700,6 +1796,8 @@
         template <typename T>
         endian_view<endian<endian::little, T> > as_little(T& v);
 
+[*Returns:] A little endian `endian_view<>` referencing the pararameter `v`.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1709,6 +1807,8 @@
         template <typename T>
         endian_view<endian<endian::big, T> > as_big(T& v);
 
+[*Returns:] A big endian `endian_view<>` referencing the pararameter `v`.
+
 [endsect]
 
 
@@ -1722,6 +1822,7 @@
 
     namespace boost {
     namespace integer {
+ namespace endianness {
 
         template <typename TargetDomain, typename SourceDomain, typename T>
         void convert_to_from(T& r);
@@ -1734,13 +1835,14 @@
         
         template <typename Endian> struct to;
         template <typename Endian> struct from;
- template <typename Endian> struct is_to;
- template <typename Endian> struct is_from;
+ template <typename Endian> struct is_target;
+ template <typename Endian> struct is_source;
 
         template <typename Endian1, typename Endian2, typename T>
         void convert(T& r);
         
 
+ } // namespace endianness
     } // namespace integer
     } // namespace boost
 
@@ -1753,6 +1855,8 @@
         template <typename TargetDomain, typename SourceDomain, typename T>
         void convert_to_from(T& r);
 
+[*Returns:] the conversion of `v` viewed from `SourceDomain` to `TargetDomain'.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1762,6 +1866,8 @@
         template <typename SourceDomain, typename T>
         void convert_from(T& r);
 
+[*Returns:] the conversion of `v` viewed from `SourceDomain` to the native doamin.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1771,6 +1877,8 @@
         template <typename TargetDomain, typename T>
         void convert_to(T& r);
 
+[*Returns:] the conversion of `v` viewed from the native to `TargetDomain'.
+
 [endsect]
 
 [/==========================================================================================]
@@ -1778,17 +1886,22 @@
 [/==========================================================================================]
 
 
+Tag class used to signal target conversion.
+
         template <typename Endian>
         struct to {
             typedef Endian type;
         };
 
+
 [endsect]
 
 [/==========================================================================================]
 [section:from Class Template `from<>`]
 [/==========================================================================================]
 
+Tag class used to signal source conversion.
+
         template <typename Endian>
         struct from {
             typedef Endian type;
@@ -1797,24 +1910,29 @@
 [endsect]
 
 [/==========================================================================================]
-[section:is_to Class Template `is_to<>`]
+[section:is_target Class Template `is_target<>`]
 [/==========================================================================================]
 
+Template metafunction stating if the tag is a target domain.
+
         template <typename Endian>
- struct is_to : mpl::false_ {};
+ struct is_target : mpl::false_ {};
         template <typename Endian>
- struct is_to< to<Endian> > : mpl::true_ {};
+ struct is_target< to<Endian> > : mpl::true_ {};
 
 [endsect]
 
 [/==========================================================================================]
-[section:is_from Class Template `is_from<>`]
+[section:is_source Class Template `is_source<>`]
 [/==========================================================================================]
 
+Template metafunction stating if the tag is a source domain.
+
         template <typename Endian>
- struct is_from : mpl::false_ {};
+ struct is_source : mpl::false_ {};
         template <typename Endian>
- struct is_from< from<Endian> > : mpl::true_ {};
+ struct is_source< from<Endian> > : mpl::true_ {};
+
 
 [endsect]
 
@@ -1822,9 +1940,13 @@
 [section:convert Non-Member Function Template `convert<>`]
 [/==========================================================================================]
 
+Coversion from source to target depending in the nature of the `Endian1` and `Endian2` template parameters. One of them must be a target domain (`to<>`) and the other a source domain (`from<>`).
+
         template <typename Endian1, typename Endian2, typename T>
         void convert(T& r);
 
+[*Returns:] the conversion of `v' viewed from source domain to the target domain'.
+
 [endsect]
 
 [endsect]
@@ -1838,7 +1960,7 @@
 [section:history Appendix A: History]
 [section [*Version 0.2.0, Febraury 15, 2011] ]
 
-Move to boost/integer/endian directory.
+Moved to boost/integer/endian directory.
 
 [endsect]
 

Modified: sandbox/endian_ext/libs/integer/endian/example/packet_example.cpp
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/example/packet_example.cpp (original)
+++ sandbox/endian_ext/libs/integer/endian/example/packet_example.cpp 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -13,7 +13,7 @@
 #define BOOST_NO_STATIC_ASSERT
 //~ #include <iostream>
 //~ #include <cassert>
-
+
 #include <boost/integer/endian/endian_pack.hpp>
 #include <boost/chrono/chrono.hpp>
 #include <boost/units/quantity.hpp>

Modified: sandbox/endian_ext/libs/integer/endian/test/Jamfile.v2
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/test/Jamfile.v2 (original)
+++ sandbox/endian_ext/libs/integer/endian/test/Jamfile.v2 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -45,8 +45,8 @@
          [ run endian_pack_test.cpp ]
          [ run endian_test.cpp ]
          [ run endian_operations_test.cpp
- : : : <toolset>gcc:<cxxflags>-Wno-sign-compare ]
- #[ run endian_in_union_test.cpp ]
+ : : : <toolset>gcc:<cxxflags>-Wno-sign-compare <define>BOOST_SHORT_ENDIAN_TEST ]
+ [ run endian_in_union_test.cpp ]
          [ run scoped_enum_emulation_test.cpp ]
          [ run endian_flip_test.cpp
          : : : <toolset>gcc:<cxxflags>-Wno-sign-compare ]

Modified: sandbox/endian_ext/libs/integer/endian/test/endian_convert_test.cpp
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/test/endian_convert_test.cpp (original)
+++ sandbox/endian_ext/libs/integer/endian/test/endian_convert_test.cpp 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -171,6 +171,7 @@
 void check_endian_send()
 {
 
+ using namespace boost::integer::endianness;
     
     //~ std::cout << std::hex << m.a.a << std::endl;
     //~ std::cout << std::hex << m.a.b << std::endl;
@@ -182,13 +183,13 @@
     //~ m.a.b=htons(m.a.b);
     //~ integer::convert_from<network>(m.b);
     convert<from<network>, to<native_endian> >(m);
- //~ convert_from<network>(m);
+ convert_from<network>(m);
     //~ std::cout << std::hex << m.a.a << std::endl;
     //~ std::cout << std::hex << m.a.b << std::endl;
     //~ std::cout << std::hex << m.b.a << std::endl;
     //~ std::cout << std::hex << m.b.b << std::endl;
 
- //~ convert_to<network>(m);
+ convert_to<network>(m);
     //~ std::cout << std::hex << m.a.a << std::endl;
     //~ std::cout << std::hex << m.a.b << std::endl;
     //~ std::cout << std::hex << m.b.a << std::endl;
@@ -212,3 +213,4 @@
     return boost::report_errors();
     //~ return 1;
 } // main
+

Modified: sandbox/endian_ext/libs/integer/endian/test/endian_convert_unique_endian_test.cpp
==============================================================================
--- sandbox/endian_ext/libs/integer/endian/test/endian_convert_unique_endian_test.cpp (original)
+++ sandbox/endian_ext/libs/integer/endian/test/endian_convert_unique_endian_test.cpp 2011-02-22 17:56:00 EST (Tue, 22 Feb 2011)
@@ -102,13 +102,13 @@
     //~ std::cout << std::hex << m.b.a << std::endl;
     //~ std::cout << std::hex << m.b.b << std::endl;
     
- integer::convert_from<network>(m);
+ integer::endianness::convert_from<network>(m);
     //~ std::cout << std::hex << m.a.a << std::endl;
     //~ std::cout << std::hex << m.a.b << std::endl;
     //~ std::cout << std::hex << m.b.a << std::endl;
     //~ std::cout << std::hex << m.b.b << std::endl;
 
- integer::convert_to<network>(m);
+ integer::endianness::convert_to<network>(m);
     //~ std::cout << std::hex << m.a.a << std::endl;
     //~ std::cout << std::hex << m.a.b << std::endl;
     //~ std::cout << std::hex << m.b.a << std::endl;


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