Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r63179 - in sandbox/endian_ext/libs/integer/doc: . html html/toward_boost_integer_endian html/toward_boost_integer_endian/appendices html/toward_boost_integer_endian/overview html/toward_boost_integer_endian/reference html/toward_boost_integer_endian/users_guide
From: vicente.botet_at_[hidden]
Date: 2010-06-20 19:53:42


Author: viboes
Date: 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
New Revision: 63179
URL: http://svn.boost.org/trac/boost/changeset/63179

Log:
Update Integer.Endian.Ext doc
Text files modified:
   sandbox/endian_ext/libs/integer/doc/html/index.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/implementation.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/rationale.html | 8
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/todo.html | 4
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/overview/motivation.html | 12
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference.html | 4
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/alignment_hpp.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/binary_stream_hpp.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/endian_domain_map_hpp.html | 6
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_binary_stream_hpp.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_conversion_hpp.html | 2
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_hpp.html | 411 --------------------------------------
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_pack_hpp.html | 282 ++++++++++++++++++++++++++
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_type_hpp.html | 4
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_view_hpp.html | 145 ++++++++++++
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endianness_hpp.html | 40 ++-
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/getting_started.html | 12
   sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/tutorial.html | 426 ++++++++++++++++++++++++++++++++++++++-
   sandbox/endian_ext/libs/integer/doc/integer_endian.qbk | 409 ++++++++++++++++++++++++++++++++------
   19 files changed, 1225 insertions(+), 550 deletions(-)

Modified: sandbox/endian_ext/libs/integer/doc/html/index.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/index.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/index.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -115,7 +115,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: June 20, 2010 at 21:56:17 GMT</small></p></td>
+<td align="left"><p><small>Last revised: June 20, 2010 at 23:47:48 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/implementation.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/implementation.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/implementation.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -32,7 +32,7 @@
       Appendix C: Implementation Notes</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.implementation.faq"></a><h4>
-<a name="id4837897"></a>
+<a name="id4846066"></a>
         <a href="implementation.html#toward_boost_integer_endian.appendices.implementation.faq">FAQ</a>
       </h4>
 <div class="itemizedlist"><ul type="disc">

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/rationale.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/rationale.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/rationale.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -32,7 +32,7 @@
       B: Rationale</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.rationale.design_considerations_for_boost_integer_endian"></a><h4>
-<a name="id4837709"></a>
+<a name="id4845742"></a>
         <a href="rationale.html#toward_boost_integer_endian.appendices.rationale.design_considerations_for_boost_integer_endian">Design
         considerations for Boost.Integer.Endian</a>
       </h4>
@@ -72,7 +72,7 @@
         </li>
 </ul></div>
 <a name="toward_boost_integer_endian.appendices.rationale.experience"></a><h4>
-<a name="id4837784"></a>
+<a name="id4758372"></a>
         <a href="rationale.html#toward_boost_integer_endian.appendices.rationale.experience">Experience</a>
       </h4>
 <p>
@@ -83,7 +83,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><h4>
-<a name="id4837817"></a>
+<a name="id4758407"></a>
         <a href="rationale.html#toward_boost_integer_endian.appendices.rationale.motivating_use_cases">Motivating
         use cases</a>
       </h4>
@@ -94,7 +94,7 @@
         places. Using Boost.Integer.Endian simplifies and cleans the code wonderfully."
       </p>
 <a name="toward_boost_integer_endian.appendices.rationale.c__0x"></a><h4>
-<a name="id4837849"></a>
+<a name="id4758438"></a>
         <a href="rationale.html#toward_boost_integer_endian.appendices.rationale.c__0x">C++0x</a>
       </h4>
 <p>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/todo.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/todo.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/appendices/todo.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -30,7 +30,7 @@
       G: Future plans</a>
 </h3></div></div></div>
 <a name="toward_boost_integer_endian.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id4839348"></a>
+<a name="id4847518"></a>
         <a href="todo.html#toward_boost_integer_endian.appendices.todo.tasks_to_do_before_review">Tasks
         to do before review</a>
       </h4>
@@ -47,7 +47,7 @@
         </li>
 </ul></div>
 <a name="toward_boost_integer_endian.appendices.todo.for_later_releases"></a><h4>
-<a name="id4839391"></a>
+<a name="id4847562"></a>
         <a href="todo.html#toward_boost_integer_endian.appendices.todo.for_later_releases">For
         later releases</a>
       </h4>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/overview/motivation.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/overview/motivation.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/overview/motivation.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -138,13 +138,13 @@
         operations.
       </p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">endian_aware_structure</span> <span class="special">{</span>
- <span class="identifier">endian_holder</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">,</span><span class="identifier">int32_t</span><span class="special">&gt;</span> <span class="identifier">a</span><span class="special">;</span>
- <span class="identifier">endian_holder</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">,</span><span class="identifier">int16_t</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+ <span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">,</span><span class="identifier">int32_t</span><span class="special">&gt;</span> <span class="identifier">a</span><span class="special">;</span>
+ <span class="identifier">endian_pack</span><span class="special">&lt;</span><span class="identifier">big</span><span class="special">,</span><span class="identifier">int16_t</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
         Structure endian_aware_structure can not be used without converting to native
- types, as endian_holder don't provide other operations than conversion.
+ types, as endian_pack don'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">// ...
@@ -156,7 +156,7 @@
         applications would benefit from the safe and transparent approach.
       </p>
 <a name="toward_boost_integer_endian.overview.motivation.in_place_conversion"></a><h4>
-<a name="id4804044"></a>
+<a name="id4804045"></a>
         <a href="motivation.html#toward_boost_integer_endian.overview.motivation.in_place_conversion">In-place
         conversion</a>
       </h4>
@@ -184,8 +184,8 @@
         endianness</a>
       </h4>
 <p>
- It has been also arged that the boost::integer::endian class didn't accepts
- a UDT. This is true when the endian is unaligned, but not for 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.
       </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>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -55,6 +55,8 @@
       Header <code class="computeroutput"><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></code></a></span></dt>
 <dt><span class="section"><a href="reference/integer_endian_pack_hpp.html">
       Header <code class="computeroutput"><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_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
+<dd><dl><dt><span class="section"><a href="reference/integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian">
+ Template class <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;&gt;</span></code></a></span></dt></dl></dd>
 <dt><span class="section"><a href="reference/integer_endian_hpp.html">
       Header <code class="computeroutput"><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">hpp</span><span class="special">&gt;</span></code></a></span></dt>
 <dd><dl><dt><span class="section"><a href="reference/integer_endian_hpp.html#toward_boost_integer_endian.reference.integer_endian_hpp.endian">
@@ -68,7 +70,7 @@
 <dt><span class="section"><a href="reference/integer_endian_view_hpp.html">
       Header <code class="computeroutput"><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_view</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
 <dd><dl>
-<dt><span class="section"><a href="reference/integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.bitfield">
+<dt><span class="section"><a href="reference/integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view">
         Template class <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="reference/integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.as_endian">
         Non-Member Function Template <code class="computeroutput"><span class="identifier">as_endian</span><span class="special">&lt;&gt;</span></code></a></span></dt>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/alignment_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/alignment_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/alignment_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -33,7 +33,7 @@
 <div class="toc"><dl><dt><span class="section"><a href="alignment_hpp.html#toward_boost_integer_endian.reference.alignment_hpp.endian_alignment">
         Enum Class <code class="computeroutput"><span class="identifier">alignment</span></code></a></span></dt></dl></div>
 <a name="toward_boost_integer_endian.reference.alignment_hpp.synopsis"></a><h4>
-<a name="id4818584"></a>
+<a name="id4820068"></a>
         <a href="alignment_hpp.html#toward_boost_integer_endian.reference.alignment_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/binary_stream_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/binary_stream_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/binary_stream_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -38,7 +38,7 @@
         and std::string types.
       </p>
 <a name="toward_boost_integer_endian.reference.binary_stream_hpp.synopsis"></a><h4>
-<a name="id4820014"></a>
+<a name="id4821346"></a>
         <a href="binary_stream_hpp.html#toward_boost_integer_endian.reference.binary_stream_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/endian_domain_map_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/endian_domain_map_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/endian_domain_map_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -33,8 +33,12 @@
 </h3></div></div></div>
 <div class="toc"><dl><dt><span class="section"><a href="endian_domain_map_hpp.html#toward_boost_integer_endian.reference.endian_domain_map_hpp.domain_map">
         Meta Function <code class="computeroutput"><span class="identifier">domain_map</span><span class="special">&lt;&gt;</span></code></a></span></dt></dl></div>
+<p>
+ This file contains the default implementation ofr the <code class="computeroutput"><span class="identifier">domaain_map</span></code>
+ metafunction.
+ </p>
 <a name="toward_boost_integer_endian.reference.endian_domain_map_hpp.synopsis"></a><h4>
-<a name="id4819462"></a>
+<a name="id4820794"></a>
         <a href="endian_domain_map_hpp.html#toward_boost_integer_endian.reference.endian_domain_map_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_binary_stream_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_binary_stream_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_binary_stream_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -38,7 +38,7 @@
         and extraction of endian types.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_binary_stream_hpp.synopsis"></a><h4>
-<a name="id4831692"></a>
+<a name="id4838659"></a>
         <a href="integer_endian_binary_stream_hpp.html#toward_boost_integer_endian.reference.integer_endian_binary_stream_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_conversion_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_conversion_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_conversion_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -49,7 +49,7 @@
         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><h4>
-<a name="id4834696"></a>
+<a name="id4842729"></a>
         <a href="integer_endian_conversion_hpp.html#toward_boost_integer_endian.reference.integer_endian_conversion_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -55,412 +55,8 @@
         byte order, value type, size, and alignment. Typedefs provide easy-to-use
         names for common configurations.
       </p>
-<p>
- Boost endian integers are based on the byte_holder endian_pack class template
- and provide in addition the same full set of C++ assignment, arithmetic,
- and relational operators as C++ standard integral types, with the standard
- semantics.
- </p>
-<p>
- Unary arithmetic operators are <code class="computeroutput"><span class="special">+</span></code>,
- <code class="computeroutput"><span class="special">-</span></code>, <code class="computeroutput"><span class="special">~</span></code>,
- <code class="computeroutput"><span class="special">!</span></code>, prefix and postfix <code class="computeroutput"><span class="special">--</span></code> and <code class="computeroutput"><span class="special">++</span></code>.
- Binary arithmetic operators are <code class="computeroutput"><span class="special">+</span></code>,
- <code class="computeroutput"><span class="special">+=</span></code>, <code class="computeroutput"><span class="special">-</span></code>,
- <code class="computeroutput"><span class="special">-=</span></code>, <code class="computeroutput"><span class="special">*</span></code>,
- <code class="computeroutput"><span class="special">*=</span></code>, <code class="computeroutput"><span class="special">/</span></code>,
- <code class="computeroutput"><span class="special">/=</span></code>, <code class="computeroutput"><span class="special">%</span></code>,
- <code class="computeroutput"><span class="special">%=</span></code>, <code class="computeroutput"><span class="special">&amp;</span></code>,
- <code class="computeroutput"><span class="special">&amp;=</span></code>, <code class="computeroutput"><span class="special">|</span></code>,
- <code class="computeroutput"><span class="special">|=</span></code>, <code class="computeroutput"><span class="special">^</span></code>,
- <code class="computeroutput"><span class="special">^=</span></code>, <code class="computeroutput"><span class="special">&lt;&lt;</span></code>,
- <code class="computeroutput"><span class="special">&lt;&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;</span></code>,
- <code class="computeroutput"><span class="special">&gt;&gt;=</span></code>. Binary relational
- operators are <code class="computeroutput"><span class="special">==</span></code>, <code class="computeroutput"><span class="special">!=</span></code>, <code class="computeroutput"><span class="special">&lt;</span></code>,
- <code class="computeroutput"><span class="special">&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;</span></code>,
- <code class="computeroutput"><span class="special">&gt;=</span></code>.
- </p>
-<p>
- Automatic conversion is provided to the underlying integer value type.
- </p>
-<a name="toward_boost_integer_endian.reference.integer_endian_hpp.typedefs"></a><h4>
-<a name="id4823459"></a>
- Typedefs
- </h4>
-<p>
- One class template is provided:
- </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</span><span class="special">;</span>
-</pre>
-<p>
- Sixty typedefs, such as big32_t, provide convenient naming conventions for
- common use cases:
- </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Name
- </p>
- </th>
-<th>
- <p>
- Endianness
- </p>
- </th>
-<th>
- <p>
- Sign
- </p>
- </th>
-<th>
- <p>
- Sizes in bits (n)
- </p>
- </th>
-<th>
- <p>
- Alignment
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">int_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>
-<td>
- <p>
- signed
- </p>
- </td>
-<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>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">uint_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>
-<td>
- <p>
- unsigned
- </p>
- </td>
-<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>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">int_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>
-<td>
- <p>
- signed
- </p>
- </td>
-<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>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">uint_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>
-<td>
- <p>
- unsigned
- </p>
- </td>
-<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>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">uint_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">native</span></code>
- </p>
- </td>
-<td>
- <p>
- signed
- </p>
- </td>
-<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>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">uint_native</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>
-<td>
- <p>
- unsigned
- </p>
- </td>
-<td>
- <p>
- 16,32,64
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_int_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>
-<td>
- <p>
- signed
- </p>
- </td>
-<td>
- <p>
- 16,32,64
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_uint_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>
-<td>
- <p>
- unsigned
- </p>
- </td>
-<td>
- <p>
- 16,32,64
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_int_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>
-<td>
- <p>
- signed
- </p>
- </td>
-<td>
- <p>
- 16,32,64
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned</span></code>
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">aligned_uint_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>
-<td>
- <p>
- unsigned
- </p>
- </td>
-<td>
- <p>
- 16,32,64
- </p>
- </td>
-<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>
-<div class="warning"><table border="0" summary="Warning">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../../doc/html/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>
-</table></div>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
-<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>
-</table></div>
-<a name="toward_boost_integer_endian.reference.integer_endian_hpp.comment_on_naming"></a><h4>
-<a name="id4824552"></a>
- <a href="integer_endian_hpp.html#toward_boost_integer_endian.reference.integer_endian_hpp.comment_on_naming">Comment
- on naming</a>
- </h4>
-<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>
- rather than <code class="computeroutput"><span class="identifier">big56_t</span></code>.
- </p>
-<p>
- As experience using these types grows, the realization creeps in that they
- are lousy arithmetic integers - they are really byte holders that for convenience
- support arithmetic operations - and that for use in internal interfaces or
- anything more than trivial arithmetic computations it is far better to convert
- values of these endian types to traditional integer types.
- </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>
 <a name="toward_boost_integer_endian.reference.integer_endian_hpp.synopsis"></a><h4>
-<a name="id4824633"></a>
+<a name="id4831597"></a>
         <a href="integer_endian_hpp.html#toward_boost_integer_endian.reference.integer_endian_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -677,10 +273,7 @@
 </pre>
 <div class="itemizedlist"><ul type="disc">
 <li>
-<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>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>
 <span class="bold"><strong>Returns:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_pack_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_pack_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_pack_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -31,19 +31,293 @@
       Header &lt;boost/integer/endian_pack.hpp&gt;">
       Header <code class="computeroutput"><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_pack</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>
 </h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian">
+ Template class <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endian">
+ Default Contructor <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endianT">
+ 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></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.assignment">
+ Assignment Operator from value_type <code class="computeroutput"><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span><span class="special">)</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.conversion">
+ Conversion Operator <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.data">
+ Member Function <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code></a></span></dt>
+</dl></dd>
+</dl></div>
 <p>
         This file contains the core class template of Boost.Integer.Endian. Provides
         byte-holder binary types with explicit control over byte order, value type,
         size, and alignment. Typedefs provide easy-to-use names for common configurations.
       </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.synopsis"></a><h4>
-<a name="id4823015"></a>
+<a name="id4824398"></a>
         <a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.synopsis">Synopsis</a>
       </h4>
+<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="identifier">BOOST_SCOPED_ENUM_START</span><span class="special">(</span><span class="identifier">alignment</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">unaligned</span><span class="special">,</span> <span class="identifier">aligned</span> <span class="special">};</span> <span class="identifier">BOOST_SCOPED_ENUM_END</span>
+
+ <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="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)*</span><span class="number">8</span><span class="special">,</span>
+ <span class="identifier">BOOST_SCOPED_ENUM</span><span class="special">(</span><span class="identifier">alignment</span><span class="special">)</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="comment">// unaligned big endian_pack signed integer types
+</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">int_least8_t</span><span class="special">,</span> <span class="number">8</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">big8_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">int_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">int_least32_t</span><span class="special">,</span> <span class="number">24</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">big24_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">int_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">int_least64_t</span><span class="special">,</span> <span class="number">40</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">big40_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">int_least64_t</span><span class="special">,</span> <span class="number">48</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">big48_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">int_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">big56_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">int_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">big64_pt</span><span class="special">;</span>
+
+ <span class="comment">// unaligned big endian_pack unsigned integer types
+</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">uint_least8_t</span><span class="special">,</span> <span class="number">8</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">ubig8_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">uint_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">big</span><span class="special">,</span> <span class="identifier">uint_least32_t</span><span class="special">,</span> <span class="number">24</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">ubig24_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">uint_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">big</span><span class="special">,</span> <span class="identifier">uint_least64_t</span><span class="special">,</span> <span class="number">40</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">ubig40_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">uint_least64_t</span><span class="special">,</span> <span class="number">48</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">ubig48_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">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">ubig56_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">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">ubig64_pt</span><span class="special">;</span>
+
+ <span class="comment">// unaligned little endian_pack signed integer types
+</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">int_least8_t</span><span class="special">,</span> <span class="number">8</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">little8_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">int_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">int_least32_t</span><span class="special">,</span> <span class="number">24</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">little24_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">int_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">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">int_least64_t</span><span class="special">,</span> <span class="number">40</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">little40_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">int_least64_t</span><span class="special">,</span> <span class="number">48</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">little48_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">int_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">little56_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">int_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">little64_pt</span><span class="special">;</span>
+
+ <span class="comment">// unaligned little endian_pack unsigned integer types
+</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">uint_least8_t</span><span class="special">,</span> <span class="number">8</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">ulittle8_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">uint_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">ulittle16_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">uint_least32_t</span><span class="special">,</span> <span class="number">24</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">ulittle24_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">uint_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">ulittle32_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">uint_least64_t</span><span class="special">,</span> <span class="number">40</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">ulittle40_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">uint_least64_t</span><span class="special">,</span> <span class="number">48</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">ulittle48_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">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">ulittle56_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">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">ulittle64_pt</span><span class="special">;</span>
+
+ <span class="comment">// unaligned native endian_pack signed integer types
+</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">int_least8_t</span><span class="special">,</span> <span class="number">8</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">native8_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">int_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">native16_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">int_least32_t</span><span class="special">,</span> <span class="number">24</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">native24_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">int_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">native32_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">int_least64_t</span><span class="special">,</span> <span class="number">40</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">native40_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">int_least64_t</span><span class="special">,</span> <span class="number">48</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">native48_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">int_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">native56_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">int_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">native64_pt</span><span class="special">;</span>
+
+ <span class="comment">// unaligned native endian_pack unsigned integer types
+</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_least8_t</span><span class="special">,</span> <span class="number">8</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">unative8_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_least16_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">unative16_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_least32_t</span><span class="special">,</span> <span class="number">24</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">unative24_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_least32_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">unaligned</span> <span class="special">&gt;</span> <span class="identifier">unative32_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">40</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">unative40_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">48</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">unative48_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">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>
+ <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="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"># 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"># 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="special">}</span>
+<span class="special">}</span>
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian" title="
+ Template class endian&lt;&gt;">
+ Template class <code class="computeroutput"><span class="identifier">endian</span><span class="special">&lt;&gt;</span></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endian">
+ Default Contructor <code class="computeroutput"><span class="identifier">endian_pack</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endianT">
+ 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></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.assignment">
+ Assignment Operator from value_type <code class="computeroutput"><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span><span class="special">)</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.conversion">
+ Conversion Operator <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.data">
+ Member Function <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code></a></span></dt>
+</dl></div>
 <p>
- An <code class="computeroutput"><span class="identifier">endian_pack</span></code> is an byte-holder
- with user-specified endianness, value type, size, and alignment.
- </p>
+ An <code class="computeroutput"><span class="identifier">endian_pack</span></code> is an 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>
+ <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="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>
+</pre>
+<div class="itemizedlist"><ul type="disc"><li>
+<span class="bold"><strong>Requires:</strong></span><div class="itemizedlist"><ul type="circle">
+<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>
+<code class="computeroutput"><span class="identifier">T</span></code> must be a POD with
+ value semantics.
+ </li>
+<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>
+ 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="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/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>
+</table></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endian"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.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 type="disc"><li>
+<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>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.endianT"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.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>
+<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 type="disc">
+<li>
+<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>
+<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>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.assignment"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.assignment" title="
+ Assignment Operator from value_type operator=(T)">
+ Assignment Operator from value_type <code class="computeroutput"><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">T</span><span class="special">)</span></code></a>
+</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 type="disc">
+<li>
+<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>
+<span class="bold"><strong>Returns:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.conversion"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.conversion" title="
+ Conversion Operator operator T()">
+ Conversion Operator <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">T</span><span class="special">()</span></code></a>
+</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 type="disc"><li>
+<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>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.data"></a><a href="integer_endian_pack_hpp.html#toward_boost_integer_endian.reference.integer_endian_pack_hpp.endian.data" title="
+ Member Function data()">
+ Member Function <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code></a>
+</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 type="disc"><li>
+<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>
+</div>
+</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_type_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_type_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_type_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -34,7 +34,7 @@
 <div class="toc"><dl><dt><span class="section"><a href="integer_endian_type_hpp.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><h4>
-<a name="id4832648"></a>
+<a name="id4839614"></a>
         <a href="integer_endian_type_hpp.html#toward_boost_integer_endian.reference.integer_endian_type_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -70,7 +70,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><h5>
-<a name="id4832966"></a>
+<a name="id4839933"></a>
           <a href="integer_endian_type_hpp.html#toward_boost_integer_endian.reference.integer_endian_type_hpp.integer_endian_type.example">Example</a>
         </h5>
 <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>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_view_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_view_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endian_view_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -32,8 +32,24 @@
       Header <code class="computeroutput"><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_view</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>
 </h3></div></div></div>
 <div class="toc"><dl>
-<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.bitfield">
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view">
         Template class <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code></a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.endian_view">
+ Constructor <code class="computeroutput"><span class="identifier">endian_view</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.operator_value_type">
+ Conversion <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">value_type</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_view_hpp.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="integer_endian_view_hpp.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>
+ <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>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement_value_type">
+ Assignement from value_type <code class="computeroutput"><span class="keyword">operator</span>
+ <span class="special">=(</span><span class="identifier">value_type</span><span class="special">)</span></code></a></span></dt>
+</dl></dd>
 <dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.as_endian">
         Non-Member Function Template <code class="computeroutput"><span class="identifier">as_endian</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.as">
@@ -43,8 +59,12 @@
 <dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.as_big">
         Non-Member Function Template <code class="computeroutput"><span class="identifier">as_big</span><span class="special">&lt;&gt;</span></code></a></span></dt>
 </dl></div>
+<p>
+ This file provides the <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code> class template as well as some factory
+ helper functions.
+ </p>
 <a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.synopsis"></a><h4>
-<a name="id4833243"></a>
+<a name="id4840230"></a>
         <a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.synopsis">Synopsis</a>
       </h4>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
@@ -56,11 +76,11 @@
     <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_pack</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>
     <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_pack</span><span class="special">&lt;</span><span class="identifier">native_endian</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>
+ <span class="identifier">endian_view</span><span class="special">&lt;</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">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>
     <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_pack</span><span class="special">&lt;</span><span class="identifier">little_endian</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>
+ <span class="identifier">endian_view</span><span class="special">&lt;</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">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>
     <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_pack</span><span class="special">&lt;</span><span class="identifier">big_endian</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>
+ <span class="identifier">endian_view</span><span class="special">&lt;</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">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>
     
 
 <span class="special">}</span> <span class="comment">// namespace integer
@@ -68,20 +88,127 @@
 </span></pre>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.bitfield"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.bitfield" title="
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view" title="
         Template class endian_view&lt;&gt;">
         Template class <code class="computeroutput"><span class="identifier">endian_view</span><span class="special">&lt;&gt;</span></code></a>
 </h4></div></div></div>
-<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>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.endian_view">
+ Constructor <code class="computeroutput"><span class="identifier">endian_view</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.operator_value_type">
+ Conversion <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">value_type</span><span class="special">()</span></code></a></span></dt>
+<dt><span class="section"><a href="integer_endian_view_hpp.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="integer_endian_view_hpp.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>
+ <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>
+<dt><span class="section"><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement_value_type">
+ Assignement from value_type <code class="computeroutput"><span class="keyword">operator</span>
+ <span class="special">=(</span><span class="identifier">value_type</span><span class="special">)</span></code></a></span></dt>
+</dl></div>
+<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">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">class</span> <span class="identifier">endian_view</span> <span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
- <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Endian</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
- <span class="keyword">typedef</span> <span class="identifier">Endian</span> <span class="identifier">endian_t</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="identifier">endian_view</span><span class="special">()=</span><span class="keyword">delete</span><span class="special">;</span>
     <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>
     <span class="keyword">operator</span> <span class="identifier">value_type</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
     <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>
+ <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>
+ <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>
 <span class="special">};</span>
 </pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.endian_view"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.endian_view" title="
+ Constructor endian_view">
+ Constructor <code class="computeroutput"><span class="identifier">endian_view</span></code></a>
+</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 type="disc"><li>
+<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>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.operator_value_type"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.operator_value_type" title="
+ Conversion operator value_type()">
+ Conversion <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">value_type</span><span class="special">()</span></code></a>
+</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 type="disc"><li>
+<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>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement" title="
+ Assignement operator =(endian_view const&amp; )">
+ 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>
+</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 type="disc">
+<li>
+<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>
+<span class="bold"><strong>Returns:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement2"></a><a href="integer_endian_view_hpp.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>
+ <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>
+</h5></div></div></div>
+<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 type="disc">
+<li>
+<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>
+<span class="bold"><strong>Returns:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement_value_type"></a><a href="integer_endian_view_hpp.html#toward_boost_integer_endian.reference.integer_endian_view_hpp.endian_view.assignement_value_type" title="
+ Assignement from value_type operator
+ =(value_type)">
+ Assignement from value_type <code class="computeroutput"><span class="keyword">operator</span>
+ <span class="special">=(</span><span class="identifier">value_type</span><span class="special">)</span></code></a>
+</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 type="disc">
+<li>
+<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>
+<span class="bold"><strong>Returns:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
+ </li>
+</ul></div>
+</div>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endianness_hpp.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endianness_hpp.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/reference/integer_endianness_hpp.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -43,13 +43,14 @@
 <dt><span class="section"><a href="integer_endianness_hpp.html#toward_boost_integer_endian.reference.integer_endianness_hpp.endian_native">
         Class <code class="computeroutput"><span class="identifier">native</span></code></a></span></dt>
 </dl></div>
+<p>
+ Header &lt;boost/endian/endianness.hpp&gt; provides the endianness tags.
+ </p>
 <a name="toward_boost_integer_endian.reference.integer_endianness_hpp.synopsis"></a><h4>
-<a name="id4818808"></a>
+<a name="id4820298"></a>
         <a href="integer_endianness_hpp.html#toward_boost_integer_endian.reference.integer_endianness_hpp.synopsis">Synopsis</a>
       </h4>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
-<span class="special">{</span>
-
+<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">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>
@@ -65,9 +66,10 @@
         Class big">
         Class <code class="computeroutput"><span class="identifier">big</span></code></a>
 </h4></div></div></div>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">big</span> <span class="special">{</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">endianness</span> <span class="identifier">value</span><span class="special">=</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">big</span><span class="special">;</span>
-<span class="special">};</span>
+<p>
+ Big endian tag.
+ </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">big</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -76,9 +78,10 @@
         Class little">
         Class <code class="computeroutput"><span class="identifier">little</span></code></a>
 </h4></div></div></div>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">little</span> <span class="special">{</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">endianness</span> <span class="identifier">value</span><span class="special">=</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">little</span><span class="special">;</span>
-<span class="special">};</span>
+<p>
+ Little endian tag.
+ </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">little</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -87,9 +90,10 @@
         Class middle">
         Class <code class="computeroutput"><span class="identifier">middle</span></code></a>
 </h4></div></div></div>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">middle</span> <span class="special">{</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">endianness</span> <span class="identifier">value</span><span class="special">=</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">middle</span><span class="special">;</span>
-<span class="special">};</span>
+<p>
+ Middle endian tag.
+ </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">middle</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -98,9 +102,10 @@
         Class mixed">
         Class <code class="computeroutput"><span class="identifier">mixed</span></code></a>
 </h4></div></div></div>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">mixed</span> <span class="special">{</span>
- <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">endianness</span> <span class="identifier">value</span><span class="special">=</span> <span class="identifier">endianness</span><span class="special">::</span><span class="identifier">mixed</span><span class="special">;</span>
-<span class="special">};</span>
+<p>
+ Mixed endian tag.
+ </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">mixed</span> <span class="special">{};</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -109,6 +114,9 @@
         Class native">
         Class <code class="computeroutput"><span class="identifier">native</span></code></a>
 </h4></div></div></div>
+<p>
+ Native endian tag.
+ </p>
 <pre class="programlisting"><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>
 </pre>
 </div>

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/getting_started.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/getting_started.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/getting_started.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -89,8 +89,8 @@
         </h5>
 <p>
           <span class="bold"><strong>Boost.Integer.Endian</strong></span> depends on some Boost
- library. For these specific parts you must use either Boost version 1.43.0
- or the version in SVN trunk (even if older version should works also).
+ library. The library has been tested with version 1.43.0 but an older version
+ should works also.
         </p>
 <a name="toward_boost_integer_endian.users_guide.getting_started.install.exceptions_safety"></a><h5>
 <a name="id4759379"></a>
@@ -102,7 +102,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><h5>
-<a name="id4759407"></a>
+<a name="id4759406"></a>
           <a href="getting_started.html#toward_boost_integer_endian.users_guide.getting_started.install.thread_safety">Thread
           safety</a>
         </h5>
@@ -110,7 +110,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><h5>
-<a name="id4759432"></a>
+<a name="id4759431"></a>
           <a href="getting_started.html#toward_boost_integer_endian.users_guide.getting_started.install.tested_compilers">Tested
           compilers</a>
         </h5>
@@ -123,10 +123,10 @@
             GCC 3.4.4 Cygwin
           </li>
 <li>
- GCC 3.4.6 Linux
+ GCC 4.4.0 MinGw
           </li>
 <li>
- GCC 4.1.2 Linux
+ MSV9 9 EXpress Windows
           </li>
 </ul></div>
 <div class="note"><table border="0" summary="Note">

Modified: sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/tutorial.html
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/tutorial.html (original)
+++ sandbox/endian_ext/libs/integer/doc/html/toward_boost_integer_endian/users_guide/tutorial.html 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -31,6 +31,8 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="tutorial.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="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers">Endian
+ unaware integers</a></span></dt></dl></dd>
 <dt><span class="section"><a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types">Endian
         unaware types</a></span></dt>
 </dl></div>
@@ -40,6 +42,8 @@
         aware types">Endian
         aware types</a>
 </h4></div></div></div>
+<div class="toc"><dl><dt><span class="section"><a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers">Endian
+ unaware integers</a></span></dt></dl></div>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic_endian_holders"></a><h5>
 <a name="id4813552"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.basic_endian_holders">basic
@@ -100,6 +104,17 @@
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.binary_streams">Binary
           streams</a>
         </h5>
+<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_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_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_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>
@@ -132,7 +147,7 @@
 <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><h5>
-<a name="id4814805"></a>
+<a name="id4814857"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_aware_unaligned_byte_holders">endian
           aware unaligned byte holders</a>
         </h5>
@@ -164,7 +179,7 @@
 <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><h5>
-<a name="id4815348"></a>
+<a name="id4815400"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_common_typedefs">endian
           holders common typedefs</a>
         </h5>
@@ -515,8 +530,8 @@
 <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 integer byte-hodlers
- are not realy integers.
+ 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
@@ -549,7 +564,7 @@
 <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><h5>
-<a name="id4816612"></a>
+<a name="id4816663"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_holders_of_udt">endian
           holders of UDT</a>
         </h5>
@@ -588,11 +603,11 @@
 <p>
           On a little-endian CPU, this program outputs:
         </p>
-<p>
- 825373492 m 825373492 m 825373492 m 1234 4321
- </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><h5>
-<a name="id4817563"></a>
+<a name="id4817656"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.arrays_of_endian_holders">Arrays
           of endian holders</a>
         </h5>
@@ -624,7 +639,7 @@
 <span class="special">}</span>
 </pre>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.structures_of_endian_holders"></a><h5>
-<a name="id4818166"></a>
+<a name="id4818259"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.structures_of_endian_holders">Structures
           of endian holders</a>
         </h5>
@@ -641,11 +656,383 @@
 <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>
-<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_integers"></a><h5>
-<a name="id4818420"></a>
- <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_integers">endian
- integers</a>
- </h5>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers"></a><a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers" title="Endian
+ unaware integers">Endian
+ unaware integers</a>
+</h5></div></div></div>
+<p>
+ Boost endian integers are based on the byte_holder endian_pack class
+ template and provide in addition the same full set of C++ assignment,
+ arithmetic, and relational operators as C++ standard integral types,
+ with the standard semantics.
+ </p>
+<p>
+ One class template is provided:
+ </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</span><span class="special">;</span>
+</pre>
+<p>
+ Unary arithmetic operators are <code class="computeroutput"><span class="special">+</span></code>,
+ <code class="computeroutput"><span class="special">-</span></code>, <code class="computeroutput"><span class="special">~</span></code>,
+ <code class="computeroutput"><span class="special">!</span></code>, prefix and postfix <code class="computeroutput"><span class="special">--</span></code> and <code class="computeroutput"><span class="special">++</span></code>.
+ Binary arithmetic operators are <code class="computeroutput"><span class="special">+</span></code>,
+ <code class="computeroutput"><span class="special">+=</span></code>, <code class="computeroutput"><span class="special">-</span></code>,
+ <code class="computeroutput"><span class="special">-=</span></code>, <code class="computeroutput"><span class="special">*</span></code>,
+ <code class="computeroutput"><span class="special">*=</span></code>, <code class="computeroutput"><span class="special">/</span></code>,
+ <code class="computeroutput"><span class="special">/=</span></code>, <code class="computeroutput"><span class="special">%</span></code>,
+ <code class="computeroutput"><span class="special">%=</span></code>, <code class="computeroutput"><span class="special">&amp;</span></code>,
+ <code class="computeroutput"><span class="special">&amp;=</span></code>, <code class="computeroutput"><span class="special">|</span></code>,
+ <code class="computeroutput"><span class="special">|=</span></code>, <code class="computeroutput"><span class="special">^</span></code>,
+ <code class="computeroutput"><span class="special">^=</span></code>, <code class="computeroutput"><span class="special">&lt;&lt;</span></code>,
+ <code class="computeroutput"><span class="special">&lt;&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;=</span></code>.
+ Binary relational operators are <code class="computeroutput"><span class="special">==</span></code>,
+ <code class="computeroutput"><span class="special">!=</span></code>, <code class="computeroutput"><span class="special">&lt;</span></code>,
+ <code class="computeroutput"><span class="special">&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;</span></code>,
+ <code class="computeroutput"><span class="special">&gt;=</span></code>.
+ </p>
+<p>
+ Automatic conversion is provided to the underlying integer value type.
+ </p>
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers.typedefs"></a><h6>
+<a name="id4818998"></a>
+ Typedefs
+ </h6>
+<p>
+ Sixty typedefs, such as big32_t, provide convenient naming conventions
+ for common use cases:
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Endianness
+ </p>
+ </th>
+<th>
+ <p>
+ Sign
+ </p>
+ </th>
+<th>
+ <p>
+ Sizes in bits (n)
+ </p>
+ </th>
+<th>
+ <p>
+ Alignment
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">int_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>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<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>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">uint_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>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<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>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">int_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>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<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>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">uint_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>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<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>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">uint_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">native</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<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>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">uint_native</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>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_int_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>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_uint_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>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_int_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>
+<td>
+ <p>
+ signed
+ </p>
+ </td>
+<td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned_uint_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>
+<td>
+ <p>
+ unsigned
+ </p>
+ </td>
+<td>
+ <p>
+ 16,32,64
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">aligned</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers.comment_on_naming"></a><h6>
+<a name="id4819846"></a>
+ <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_aware_types.endian_unaware_integers.comment_on_naming">Comment
+ on naming</a>
+ </h6>
+<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>.
+ </p>
+<p>
+ As experience using these types grows, the realization creeps in that
+ they are lousy arithmetic integers - they are really byte holders that
+ for convenience support arithmetic operations - and that for use in internal
+ interfaces or anything more than trivial arithmetic computations it is
+ far better to convert values of these endian types to traditional integer
+ types.
+ </p>
+</div>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h4 class="title">
@@ -654,12 +1041,17 @@
         unaware types</a>
 </h4></div></div></div>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.working_with_third_party_structures"></a><h5>
-<a name="id4818460"></a>
+<a name="id4819923"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.working_with_third_party_structures">Working
           with third party structures</a>
         </h5>
+<a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.domain_map"></a><h5>
+<a name="id4819946"></a>
+ <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.domain_map">Domain
+ map</a>
+ </h5>
 <a name="toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.in_place_conversions"></a><h5>
-<a name="id4818484"></a>
+<a name="id4819968"></a>
           <a href="tutorial.html#toward_boost_integer_endian.users_guide.tutorial.endian_unaware_types.in_place_conversions">In-place
           conversions</a>
         </h5>

Modified: sandbox/endian_ext/libs/integer/doc/integer_endian.qbk
==============================================================================
--- sandbox/endian_ext/libs/integer/doc/integer_endian.qbk (original)
+++ sandbox/endian_ext/libs/integer/doc/integer_endian.qbk 2010-06-20 19:53:37 EDT (Sun, 20 Jun 2010)
@@ -136,12 +136,12 @@
 The extension proposal separates the endian aware byte-holder type from the one able to make arithmetic operations so the user will be forced to convert for one to/from the native type, and avoid unfortunate costly atithmetic operations.
 
     struct endian_aware_structure {
- endian_holder<big,int32_t> a;
- endian_holder<big,int16_t> b;
+ endian_pack<big,int32_t> a;
+ endian_pack<big,int16_t> b;
     };
 
 
-Structure endian_aware_structure can not be used without converting to native types, as endian_holder don't provide other operations than conversion.
+Structure endian_aware_structure can not be used without converting to native types, as endian_pack don't provide other operations than conversion.
 
     endian_aware_structure st;
     // ...
@@ -169,7 +169,7 @@
 [heading UDT endianness]
 [/=====================]
 
-It has been also arged that the boost::integer::endian class didn't accepts a UDT. This is true when the endian is unaligned, but not for 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;
@@ -274,7 +274,7 @@
 [heading Requirements]
 [/=========================]
 
-[*Boost.Integer.Endian] depends on some Boost library. For these specific parts you must use either Boost version 1.43.0 or the version in SVN trunk (even if older version should works also).
+[*Boost.Integer.Endian] depends on some Boost library. The library has been tested with version 1.43.0 but an older version should works also.
 
 
 [/========================]
@@ -296,9 +296,11 @@
 Currently, [*Boost.Integer.Endian] has been tested in the following compilers/platforms:
 
 * GCC 3.4.4 Cygwin
-* GCC 3.4.6 Linux
+* GCC 4.4.0 MinGw
+* MSV9 9 EXpress Windows
+
 [/* GCC 4.3.2 Cygwin]
-* GCC 4.1.2 Linux
+[/* GCC 4.1.2 Linux]
 
 [note Please send any questions, comments and bug reports to boost <at> lists <dot> boost <dot> org.]
 
@@ -410,6 +412,10 @@
 
 [heading 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.
+
+Header <boost/integer/endian_binary_stream.hpp> provides operators `<=` and `=>` for unformatted binary (as opposed to formatted character) stream insertion and extraction of endian types.
+
     #include <boost/integer/endian_pack.hpp>
     #include <boost/integer/endian_binary_stream.hpp>
     #include <boost/binary_stream.hpp>
@@ -500,7 +506,7 @@
 
 [*Comment on naming]
 
-When first exposed to endian types, programmers often fit them into a mental model based on the <cstdint> types. Using that model, it is natural to expect a 56-bit big-endian signed integer to be named `int_big56_t`. But these integer byte-hodlers are not realy integers.
+When first exposed to endian types, programmers often fit them into a mental model based on the <cstdint> types. Using that model, it is natural to expect a 56-bit big-endian signed integer to be named `int_big56_t`. But these byte-hodlers are not realy integers.
 
 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 `big56_t` is a good reflection of the mental model.
 
@@ -562,8 +568,8 @@
 
 On a little-endian CPU, this program outputs:
 
-825373492 m 825373492 m 825373492 m
-1234 4321
+ 825373492 m 825373492 m 825373492 m
+ 1234 4321
 
 [heading Arrays of endian holders]
 
@@ -608,10 +614,52 @@
     header.checksum = checksum_of(p);
 
 
-[heading endian integers]
+[/===========================]
+[section Endian unaware integers]
+[/===========================]
+
+Boost endian integers are based on the byte_holder endian_pack class template and provide in addition the same full set of C++ assignment, arithmetic, and relational operators as C++ standard integral types, with the standard semantics.
+
+One class template is provided:
+
+ template <endianness::enum_t E, typename T, std::size_t n_bytes=8*sizeof(T),
+ alignment::enum_t A = alignment::aligned>
+ class endian;
+
+Unary arithmetic operators are `+`, `-`, `~`, `!`, prefix and postfix `--` and `++`. Binary arithmetic operators are `+`, `+=`, `-`, `-=`, `*`, `*=`, `/`, `/=`, `%`, `%=`, `&`, `&=`, `|`, `|=`, `^`, `^=`, `<<`, `<<=`, `>>`, `>>=`. Binary relational operators are `==`, `!=`, `<`, `<=`, `>`, `>=`.
+
+Automatic conversion is provided to the underlying integer value type.
+
+[heading Typedefs]
+
+
+Sixty typedefs, such as big32_t, provide convenient naming conventions for common use cases:
+
+
+[table
+ [[Name] [Endianness] [Sign] [Sizes in bits (n)] [Alignment]]
+ [[`int_big`*n*`_t`] [`big`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
+ [[`uint_big`*n*`_t`] [`big`] [unsigned] [8,16,24,32,40,48,56,64] [`unaligned`]]
+ [[`int_little`*n*`_t`] [`little`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
+ [[`uint_little`*n*`_t`] [`little`] [unsigned] [8,16,24,32,40,48,56,64] [`unaligned`]]
+ [[`uint_little`*n*`_t`] [`native`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
+ [[`uint_native`*n*`_t`] [`native`] [unsigned] [16,32,64] [`aligned`]]
+ [[`aligned_int_big`*n*`_t`] [`big`] [signed] [16,32,64] [`aligned`]]
+ [[`aligned_uint_big`*n*`_t`] [`big`] [unsigned] [16,32,64] [`aligned`]]
+ [[`aligned_int_little`*n*`_t`] [`little`] [signed] [16,32,64] [`aligned`]]
+ [[`aligned_uint_little`*n*`_t`] [`little`] [unsigned] [16,32,64] [`aligned`]]
+]
+
+
+[heading Comment on naming]
+
+When first exposed to endian types, programmers often fit them into a mental model based on the <cstdint> types. Using that model, it is natural to expect a 56-bit big-endian signed integer to be named `int_big56_t`.
+
+As experience using these types grows, the realization creeps in that they are lousy arithmetic integers - they are really byte holders that for convenience support arithmetic operations - and that for use in internal interfaces or anything more than trivial arithmetic computations it is far better to convert values of these endian types to traditional integer types.
 
 
 [endsect]
+[endsect]
 
 [/===========================]
 [section Endian unaware types]
@@ -620,6 +668,8 @@
 [heading Working with third party structures]
 
 
+[heading Domain map]
+
 [heading In-place conversions]
 
 [endsect]
@@ -682,11 +732,11 @@
 [section:integer_endianness_hpp Header `<boost/integer/endiannes.hpp>`]
 [/==========================================================================================]
 
-[heading Synopsis]
+Header <boost/endian/endianness.hpp> provides the endianness tags.
 
- namespace boost
- {
+[heading Synopsis]
 
+ namespace boost {
         namespace endianness {
             struct big;
             struct little;
@@ -714,9 +764,9 @@
 [section:endian_big Class `big`]
 [/==========================================================================================]
 
- struct big {
- static const endianness value= endianness::big;
- };
+Big endian tag.
+
+ struct big {};
 
 
 [endsect]
@@ -724,9 +774,9 @@
 [section:endian_little Class `little`]
 [/==========================================================================================]
 
- struct little {
- static const endianness value= endianness::little;
- };
+Little endian tag.
+
+ struct little {};
 
 
 [endsect]
@@ -734,18 +784,18 @@
 [section:endian_middle Class `middle`]
 [/==========================================================================================]
 
- struct middle {
- static const endianness value= endianness::middle;
- };
+Middle endian tag.
+
+ struct middle {};
 
 [endsect]
 [/==========================================================================================]
 [section:endian_mixed Class `mixed`]
 [/==========================================================================================]
 
- struct mixed {
- static const endianness value= endianness::mixed;
- };
+Mixed endian tag.
+
+ struct mixed {};
 
 
 [endsect]
@@ -753,6 +803,8 @@
 [section:endian_native Class `native`]
 [/==========================================================================================]
 
+Native endian tag.
+
             typedef <platform dependent> native ;
 
 
@@ -764,6 +816,7 @@
 [section:endian_domain_map_hpp Header `<boost/endian/domain_map.hpp>`]
 [/==========================================================================================]
 
+This file contains the default implementation ofr the `domaain_map` metafunction.
 
 [heading Synopsis]
 
@@ -903,63 +956,217 @@
 
 [heading Synopsis]
 
+ namespace boost {
+ namespace integer {
+ BOOST_SCOPED_ENUM_START(alignment) { unaligned, aligned }; BOOST_SCOPED_ENUM_END
+
+ template <typename E,
+ typename T,
+ std::size_t n_bits=sizeof(T)*8,
+ BOOST_SCOPED_ENUM(alignment) A = alignment::aligned
+ > class endian_pack;
+
+ // unaligned big endian_pack signed integer types
+ typedef endian_pack< endianness::big, int_least8_t, 8, alignment::unaligned > big8_pt;
+ typedef endian_pack< endianness::big, int_least16_t, 16, alignment::unaligned > big16_pt;
+ typedef endian_pack< endianness::big, int_least32_t, 24, alignment::unaligned > big24_pt;
+ typedef endian_pack< endianness::big, int_least32_t, 32, alignment::unaligned > big32_pt;
+ typedef endian_pack< endianness::big, int_least64_t, 40, alignment::unaligned > big40_pt;
+ typedef endian_pack< endianness::big, int_least64_t, 48, alignment::unaligned > big48_pt;
+ typedef endian_pack< endianness::big, int_least64_t, 56, alignment::unaligned > big56_pt;
+ typedef endian_pack< endianness::big, int_least64_t, 64, alignment::unaligned > big64_pt;
+
+ // unaligned big endian_pack unsigned integer types
+ typedef endian_pack< endianness::big, uint_least8_t, 8, alignment::unaligned > ubig8_pt;
+ typedef endian_pack< endianness::big, uint_least16_t, 16, alignment::unaligned > ubig16_pt;
+ typedef endian_pack< endianness::big, uint_least32_t, 24, alignment::unaligned > ubig24_pt;
+ typedef endian_pack< endianness::big, uint_least32_t, 32, alignment::unaligned > ubig32_pt;
+ typedef endian_pack< endianness::big, uint_least64_t, 40, alignment::unaligned > ubig40_pt;
+ typedef endian_pack< endianness::big, uint_least64_t, 48, alignment::unaligned > ubig48_pt;
+ typedef endian_pack< endianness::big, uint_least64_t, 56, alignment::unaligned > ubig56_pt;
+ typedef endian_pack< endianness::big, uint_least64_t, 64, alignment::unaligned > ubig64_pt;
+
+ // unaligned little endian_pack signed integer types
+ typedef endian_pack< endianness::little, int_least8_t, 8, alignment::unaligned > little8_pt;
+ typedef endian_pack< endianness::little, int_least16_t, 16, alignment::unaligned > little16_pt;
+ typedef endian_pack< endianness::little, int_least32_t, 24, alignment::unaligned > little24_pt;
+ typedef endian_pack< endianness::little, int_least32_t, 32, alignment::unaligned > little32_pt;
+ typedef endian_pack< endianness::little, int_least64_t, 40, alignment::unaligned > little40_pt;
+ typedef endian_pack< endianness::little, int_least64_t, 48, alignment::unaligned > little48_pt;
+ typedef endian_pack< endianness::little, int_least64_t, 56, alignment::unaligned > little56_pt;
+ typedef endian_pack< endianness::little, int_least64_t, 64, alignment::unaligned > little64_pt;
+
+ // unaligned little endian_pack unsigned integer types
+ typedef endian_pack< endianness::little, uint_least8_t, 8, alignment::unaligned > ulittle8_pt;
+ typedef endian_pack< endianness::little, uint_least16_t, 16, alignment::unaligned > ulittle16_pt;
+ typedef endian_pack< endianness::little, uint_least32_t, 24, alignment::unaligned > ulittle24_pt;
+ typedef endian_pack< endianness::little, uint_least32_t, 32, alignment::unaligned > ulittle32_pt;
+ typedef endian_pack< endianness::little, uint_least64_t, 40, alignment::unaligned > ulittle40_pt;
+ typedef endian_pack< endianness::little, uint_least64_t, 48, alignment::unaligned > ulittle48_pt;
+ typedef endian_pack< endianness::little, uint_least64_t, 56, alignment::unaligned > ulittle56_pt;
+ typedef endian_pack< endianness::little, uint_least64_t, 64, alignment::unaligned > ulittle64_pt;
+
+ // unaligned native endian_pack signed integer types
+ typedef endian_pack< endianness::native, int_least8_t, 8, alignment::unaligned > native8_pt;
+ typedef endian_pack< endianness::native, int_least16_t, 16, alignment::unaligned > native16_pt;
+ typedef endian_pack< endianness::native, int_least32_t, 24, alignment::unaligned > native24_pt;
+ typedef endian_pack< endianness::native, int_least32_t, 32, alignment::unaligned > native32_pt;
+ typedef endian_pack< endianness::native, int_least64_t, 40, alignment::unaligned > native40_pt;
+ typedef endian_pack< endianness::native, int_least64_t, 48, alignment::unaligned > native48_pt;
+ typedef endian_pack< endianness::native, int_least64_t, 56, alignment::unaligned > native56_pt;
+ typedef endian_pack< endianness::native, int_least64_t, 64, alignment::unaligned > native64_pt;
+
+ // unaligned native endian_pack unsigned integer types
+ typedef endian_pack< endianness::native, uint_least8_t, 8, alignment::unaligned > unative8_pt;
+ typedef endian_pack< endianness::native, uint_least16_t, 16, alignment::unaligned > unative16_pt;
+ typedef endian_pack< endianness::native, uint_least32_t, 24, alignment::unaligned > unative24_pt;
+ typedef endian_pack< endianness::native, uint_least32_t, 32, alignment::unaligned > unative32_pt;
+ typedef endian_pack< endianness::native, uint_least64_t, 40, alignment::unaligned > unative40_pt;
+ typedef endian_pack< endianness::native, uint_least64_t, 48, alignment::unaligned > unative48_pt;
+ 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
+
+ // aligned native endian_pack typedefs are not provided because
+ // <cstdint> types are superior for this use case
+
+ # 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
+
+ # 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
+
+ # 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
+
+ }
+ }
+
+[/==========================================================================================]
+[section:endian_pack Template class `endian_pack<>`]
+[/==========================================================================================]
 
 An `endian_pack` is an byte-holder with user-specified endianness, value type, size, and alignment.
 
+ template <
+ typename E,
+ typename T,
+ std::size_t n_bits=8*sizeof(T),
+ alignment A = alignment::aligned>
+ class endian_pack {
+ public:
+ 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
+ explicit endian_pack(T v);
+ 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]
+
+
+[/==========================================================================================]
+[section:endian Default Contructor `endian_pack()`]
+[/==========================================================================================]
+
+ endian_pack() = default; // C++03: endian(){}
+
+* [*Effects:] Constructs an object of type `endian<E, T, n_bits, A>`.
 
 [endsect]
 
 [/==========================================================================================]
-[section:integer_endian_hpp Header `<boost/integer/endian.hpp>`]
+[section:endianT Contructor from value_type `endian_pack(T)`]
 [/==========================================================================================]
 
-Header `<boost/integer/endian.hpp>` provides integer-like byte-holder binary types with explicit control over byte order, value type, size, and alignment. Typedefs provide easy-to-use names for common configurations.
+ explicit endian_pack(T v);
 
-Boost endian integers are based on the byte_holder endian_pack class template and provide in addition the same full set of C++ assignment, arithmetic, and relational operators as C++ standard integral types, with the standard semantics.
+* [*Effects:] Constructs an object of type `endian_pack<E, T, n_bits, A>`.
+* [*Postcondition:] `x == v`, where `x` is the constructed object.
 
-Unary arithmetic operators are `+`, `-`, `~`, `!`, prefix and postfix `--` and `++`. Binary arithmetic operators are `+`, `+=`, `-`, `-=`, `*`, `*=`, `/`, `/=`, `%`, `%=`, `&`, `&=`, `|`, `|=`, `^`, `^=`, `<<`, `<<=`, `>>`, `>>=`. Binary relational operators are `==`, `!=`, `<`, `<=`, `>`, `>=`.
+[endsect]
 
-Automatic conversion is provided to the underlying integer value type.
+[/==========================================================================================]
+[section:assignment Assignment Operator from value_type `operator=(T)`]
+[/==========================================================================================]
 
-[heading Typedefs]
+ endian & operator=(T v);
 
-One class template is provided:
+* [*Postcondition:] `x == v`, where `x` is the constructed object.
+* [*Returns:] `*this`.
 
- template <endianness::enum_t E, typename T, std::size_t n_bytes=8*sizeof(T),
- alignment::enum_t A = alignment::aligned>
- class endian;
+[endsect]
 
-Sixty typedefs, such as big32_t, provide convenient naming conventions for common use cases:
+[/==========================================================================================]
+[section:conversion Conversion Operator `operator T()`]
+[/==========================================================================================]
 
+ operator T() const;
 
-[table
- [[Name] [Endianness] [Sign] [Sizes in bits (n)] [Alignment]]
- [[`int_big`*n*`_t`] [`big`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
- [[`uint_big`*n*`_t`] [`big`] [unsigned] [8,16,24,32,40,48,56,64] [`unaligned`]]
- [[`int_little`*n*`_t`] [`little`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
- [[`uint_little`*n*`_t`] [`little`] [unsigned] [8,16,24,32,40,48,56,64] [`unaligned`]]
- [[`uint_little`*n*`_t`] [`native`] [signed] [8,16,24,32,40,48,56,64] [`unaligned`]]
- [[`uint_native`*n*`_t`] [`native`] [unsigned] [16,32,64] [`aligned`]]
- [[`aligned_int_big`*n*`_t`] [`big`] [signed] [16,32,64] [`aligned`]]
- [[`aligned_uint_big`*n*`_t`] [`big`] [unsigned] [16,32,64] [`aligned`]]
- [[`aligned_int_little`*n*`_t`] [`little`] [signed] [16,32,64] [`aligned`]]
- [[`aligned_uint_little`*n*`_t`] [`little`] [unsigned] [16,32,64] [`aligned`]]
-]
+* [*Returns:] The current value stored in `*this`, converted to `value_type`.
 
-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.
+[endsect]
 
-[warning 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.]
+[/==========================================================================================]
+[section:data Member Function `data()`]
+[/==========================================================================================]
 
-[note One-byte big-endian, little-endian, and native-endian types provide identical functionality. All three names are provided to improve code readability and searchability.
-]
+ const char* data() const;
 
-[heading Comment on naming]
+* [*Returns:] The current value stored in `*this`, converted to `value_type`.
 
-When first exposed to endian types, programmers often fit them into a mental model based on the <cstdint> types. Using that model, it is natural to expect a 56-bit big-endian signed integer to be named `int_big56_t` rather than `big56_t`.
+[endsect]
 
-As experience using these types grows, the realization creeps in that they are lousy arithmetic integers - they are really byte holders that for convenience support arithmetic operations - and that for use in internal interfaces or anything more than trivial arithmetic computations it is far better to convert values of these endian types to traditional integer types.
+[endsect]
+
+[/==========================================================================================]
+[section:typedefs Common typedefs]
+[/==========================================================================================]
+
+[endsect]
+
+[endsect]
+[/==========================================================================================]
+[section:integer_endian_hpp Header `<boost/integer/endian.hpp>`]
+[/==========================================================================================]
+
+Header `<boost/integer/endian.hpp>` provides integer-like byte-holder binary types with explicit control over byte order, value type, size, and alignment. Typedefs provide easy-to-use names for common configurations.
 
-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 `big56_t` is a good reflection of the mental model.
 
 [heading Synopsis]
 
@@ -1124,7 +1331,7 @@
 
     endian & operator=(T v);
 
-* [*Postcondition:] `x == v`, where `x` is the constructed object.
+* [*Postcondition:] `value_type(*this) == v`.
 * [*Returns:] `*this`.
 
 [endsect]
@@ -1158,6 +1365,13 @@
 [endsect]
 
 [endsect]
+
+[/==========================================================================================]
+[section:typedefs Common typedefs]
+[/==========================================================================================]
+
+[endsect]
+
 [endsect]
 
 [/==========================================================================================]
@@ -1233,6 +1447,8 @@
 [section:integer_endian_view_hpp Header `<boost/integer/endian_view.hpp>`]
 [/==========================================================================================]
 
+This file provides the `endian_view<>` class template as well as some factory helper functions.
+
 [heading Synopsis]
 
     namespace boost {
@@ -1244,30 +1460,90 @@
         template <typename E, typename T>
         endian_view<endian_pack<E,T> > as_endian(T& v);
         template <typename T>
- endian_view<endian_pack<native_endian, T> > as(T& v);
+ endian_view<endian_pack<endianness::native, T> > as(T& v);
         template <typename T>
- endian_view<endian_pack<little_endian,T> > as_little(T& v);
+ endian_view<endian_pack<endianness::little,T> > as_little(T& v);
         template <typename T>
- endian_view<endian_pack<big_endian,T> > as_big(T& v);
+ endian_view<endian_pack<endianness::big,T> > as_big(T& v);
         
 
     } // namespace integer
     } // namespace boost
 
 [/==========================================================================================]
-[section:bitfield Template class `endian_view<>`]
+[section:endian_view Template class `endian_view<>`]
 [/==========================================================================================]
 
- template <typename Endian>
+ template <typename Endian, typename T>
         class endian_view {
         public:
- typedef typename Endian::value_type value_type;
- typedef Endian endian_t;
+ typedef T value_type;
+ endian_view()=delete;
             endian_view(value_type& ref);
             operator value_type() const;
             endian_view& operator=(value_type val);
+ endian_view& operator=(endian_view const& rhs);
+ template <typename Endian2 >
+ endian_view& operator=(endian_view<Endian2,T> const& rhs) {
         };
 
+[/==========================================================================================]
+[section:endian_view Constructor `endian_view`]
+[/==========================================================================================]
+
+ endian_view(value_type& ref);
+
+* [*Effects:] Constructs an object of type `endian_view<E, T, n_bits, A>`.
+
+[endsect]
+
+[/==========================================================================================]
+[section:operator_value_type Conversion `operator value_type()`]
+[/==========================================================================================]
+
+ operator value_type() const;
+
+* [*Returns:] The converted `value_type` of the referenced type as it was seen as an endian aware type.
+
+[endsect]
+
+[/==========================================================================================]
+[section:assignement Assignement `operator =(endian_view const& )`]
+[/==========================================================================================]
+
+ endian_view& operator=(endian_view const& rhs);
+
+* [*Postcondition:] `this->ref_ == rhs.ref_`.
+* [*Returns:] `*this`.
+
+[endsect]
+
+[/==========================================================================================]
+[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`.
+
+[endsect]
+
+
+[/==========================================================================================]
+[section:assignement_value_type Assignement from value_type `operator =(value_type)`]
+[/==========================================================================================]
+
+ endian_view& operator=(value_type val);
+
+* [*Postcondition:] `value_type(this->ref_) == v`.
+* [*Returns:] `*this`.
+
+[endsect]
+
+
+
 [endsect]
 
 [/==========================================================================================]
@@ -1708,4 +1984,3 @@
 
 
 [endsect]
-


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