feedc0de/boost_endian
1
0
Fork 0
forked from boostorg/endian
Code Pull Requests Activity

Rename the endian typedefs. Rationale: Subjective - during three months working on the B-tree library, the *un_t names were a constant source of irritation. Objective - the new scheme, which reverts the *un_t names to having no alignment decoration, provides consistent *_align* decoration for both FP and integer types. Also, the library now provides conversion functions which may reduce use of aligned endian types.

Browse Source
This commit is contained in:
Beman
2013-09-01 08:40:32 -04:00
parent d1d62f3adc
commit 016d3b2e7c
10 changed files with 902 additions and 902 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
doc/types.html
View File

@@ -227,98 +227,98 @@ conventions for common use cases:</p>
<td width="49%" align="center"><b><i>Alignment</i></b></td> <td width="49%" align="center"><b><i>Alignment</i></b></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>big_int</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>big_align_int</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>big</code></td> <td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td> <td width="10%" align="center">signed</td>
<td width="15%">16,32,64</td> <td width="15%">16,32,64</td>
<td width="49%" align="center"><code>yes</code></td> <td width="49%" align="center"><code>yes</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>big_uint</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>big_align_uint</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>big</code></td> <td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">unsigned</td> <td width="10%" align="center">unsigned</td>
<td width="15%">16,32,64</td> <td width="15%">16,32,64</td>
<td width="49%" align="center"><code>yes</code></td> <td width="49%" align="center"><code>yes</code></td>
</tr> </tr>
<tr>
<td width="18%"><code>big_align_float</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">32,64</td>
<td width="49%" align="center"><code>yes</code></td>
</tr>
<tr>
<td width="18%"><code>little_align_int</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">16,32,64</td>
<td width="49%" align="center"><code>yes</code></td>
</tr>
<tr>
<td width="18%"><code>little_align_uint</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">unsigned</td>
<td width="15%">16,32,64</td>
<td width="49%" align="center"><code>yes</code></td>
</tr>
<tr>
<td width="18%"><code>little_align_float</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">32,64</td>
<td width="49%" align="center"><code>yes</code></td>
</tr>
<tr>
<td width="18%"><code>big_int</code><b><i>n</i></b><code>_t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>big_uint</code><i><b>n</b></i><code>_</code><code>t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">unsigned</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr> <tr>
<td width="18%"><code>big_float</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>big_float</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>big</code></td> <td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td> <td width="10%" align="center">signed</td>
<td width="15%">32,64</td> <td width="15%">32,64</td>
<td width="49%" align="center"><code>yes</code></td> <td width="49%" align="center"><code>no</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>little_int</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>little_int</code><i><b>n</b></i><code>_</code><code>t</code></td>
<td width="10%" align="center"><code>little</code></td> <td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td> <td width="10%" align="center">signed</td>
<td width="15%">16,32,64</td> <td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>yes</code></td> <td width="49%" align="center"><code>no</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>little_uint</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>little_uint</code><i><b>n</b></i><code>_</code><code>t</code></td>
<td width="10%" align="center"><code>little</code></td> <td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">unsigned</td> <td width="10%" align="center">unsigned</td>
<td width="15%">16,32,64</td> <td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>yes</code></td> <td width="49%" align="center"><code>no</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>little_float</code><i><b>n</b></i><code>_t</code></td> <td width="18%"><code>little_float</code><i><b>n</b></i><code>_t</code></td>
<td width="10%" align="center"><code>little</code></td> <td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td> <td width="10%" align="center">signed</td>
<td width="15%">32,64</td> <td width="15%">32,64</td>
<td width="49%" align="center"><code>yes</code></td>
</tr>
<tr>
<td width="18%"><code>big_int</code><b><i>n</i></b><code>un_t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td> <td width="49%" align="center"><code>no</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>big_uint</code><i><b>n</b></i><code>un_</code><code>t</code></td> <td width="18%"><code>native_int</code><i><b>n</b></i><code>_</code><code>t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">unsigned</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>big_float</code><i><b>n</b></i><code>un_t</code></td>
<td width="10%" align="center"><code>big</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">32,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>little_int</code><i><b>n</b></i><code>un_</code><code>t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>little_uint</code><i><b>n</b></i><code>un_</code><code>t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">unsigned</td>
<td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>little_float</code><i><b>n</b></i><code>un_t</code></td>
<td width="10%" align="center"><code>little</code></td>
<td width="10%" align="center">signed</td>
<td width="15%">32,64</td>
<td width="49%" align="center"><code>no</code></td>
</tr>
<tr>
<td width="18%"><code>native_int</code><i><b>n</b></i><code>un_</code><code>t</code></td>
<td width="10%" align="center"><code>native</code></td> <td width="10%" align="center"><code>native</code></td>
<td width="10%" align="center">signed</td> <td width="10%" align="center">signed</td>
<td width="15%">8,16,24,32,40,48,56,64</td> <td width="15%">8,16,24,32,40,48,56,64</td>
<td width="49%" align="center"><code>no</code></td> <td width="49%" align="center"><code>no</code></td>
</tr> </tr>
<tr> <tr>
<td width="18%"><code>native_uint</code><i><b>n</b></i><code>un_</code><code>t</code></td> <td width="18%"><code>native_uint</code><i><b>n</b></i><code>_</code><code>t</code></td>
<td width="10%" align="center"><code>native</code></td> <td width="10%" align="center"><code>native</code></td>
<td width="10%" align="center">unsigned</td> <td width="10%" align="center">unsigned</td>
<td width="15%">8,16,24,32,40,48,56,64</td> <td width="15%">8,16,24,32,40,48,56,64</td>
@@ -387,103 +387,103 @@ usual operations on integers are supplied.</p>
endian operator--(endian&amp; x, int) noexcept; endian operator--(endian&amp; x, int) noexcept;
}; };
typedef endian&lt;order::big, float, 32, align::yes&gt; big_float32_t; typedef endian&lt;order::big, float, 32, align::yes&gt; big_align_float32_t;
typedef endian&lt;order::big, double, 64, align::yes&gt; big_float64_t; typedef endian&lt;order::big, double, 64, align::yes&gt; big_align_float64_t;
// aligned little endian floating point types // aligned little endian floating point types
typedef endian&lt;order::little, float, 32, align::yes&gt; little_float32_t; typedef endian&lt;order::little, float, 32, align::yes&gt; little_align_float32_t;
typedef endian&lt;order::little, double, 64, align::yes&gt; little_float64_t; typedef endian&lt;order::little, double, 64, align::yes&gt; little_align_float64_t;
// unaligned big endian floating point types // unaligned big endian floating point types
typedef endian&lt;order::big, float, 32, align::no&gt; big_float32un_t; typedef endian&lt;order::big, float, 32, align::no&gt; big_float32un_t;
typedef endian&lt;order::big, double, 64, align::no&gt; big_float64un_t; typedef endian&lt;order::big, double, 64, align::no&gt; big_float64un_t;
// unaligned little endian floating point types // unaligned little endian floating point types
typedef endian&lt;order::little, float, 32, align::no&gt; little_float32un_t; typedef endian&lt;order::little, float, 32, align::no&gt; little_float32un_t;
typedef endian&lt;order::little, double, 64, align::no&gt; little_float64un_t; typedef endian&lt;order::little, double, 64, align::no&gt; little_float64un_t;
// aligned big endian signed integer types // aligned big endian signed integer types
typedef endian&lt;order::big, int16_t, 16, align::yes&gt; big_int16_t; typedef endian&lt;order::big, int16_t, 16, align::yes&gt; big_align_int16_t;
typedef endian&lt;order::big, int32_t, 32, align::yes&gt; big_int32_t; typedef endian&lt;order::big, int32_t, 32, align::yes&gt; big_align_int32_t;
typedef endian&lt;order::big, int64_t, 64, align::yes&gt; big_int64_t; typedef endian&lt;order::big, int64_t, 64, align::yes&gt; big_align_int64_t;
// aligned big endian unsigned integer types // aligned big endian unsigned integer types
typedef endian&lt;order::big, uint16_t, 16, align::yes&gt; big_uint16_t; typedef endian&lt;order::big, uint16_t, 16, align::yes&gt; big_align_uint16_t;
typedef endian&lt;order::big, uint32_t, 32, align::yes&gt; big_uint32_t; typedef endian&lt;order::big, uint32_t, 32, align::yes&gt; big_align_uint32_t;
typedef endian&lt;order::big, uint64_t, 64, align::yes&gt; big_uint64_t; typedef endian&lt;order::big, uint64_t, 64, align::yes&gt; big_align_uint64_t;
// aligned little endian signed integer types // aligned little endian signed integer types
typedef endian&lt;order::little, int16_t, 16, align::yes&gt; little_int16_t; typedef endian&lt;order::little, int16_t, 16, align::yes&gt; little_align_int16_t;
typedef endian&lt;order::little, int32_t, 32, align::yes&gt; little_int32_t; typedef endian&lt;order::little, int32_t, 32, align::yes&gt; little_align_int32_t;
typedef endian&lt;order::little, int64_t, 64, align::yes&gt; little_int64_t; typedef endian&lt;order::little, int64_t, 64, align::yes&gt; little_align_int64_t;
// aligned little endian unsigned integer types // aligned little endian unsigned integer types
typedef endian&lt;order::little, uint16_t, 16, align::yes&gt; little_uint16_t; typedef endian&lt;order::little, uint16_t, 16, align::yes&gt; little_align_uint16_t;
typedef endian&lt;order::little, uint32_t, 32, align::yes&gt; little_uint32_t; typedef endian&lt;order::little, uint32_t, 32, align::yes&gt; little_align_uint32_t;
typedef endian&lt;order::little, uint64_t, 64, align::yes&gt; little_uint64_t; typedef endian&lt;order::little, uint64_t, 64, align::yes&gt; little_align_uint64_t;
// aligned native endian typedefs are not provided because // aligned native endian typedefs are not provided because
// &lt;cstdint&gt; types are superior for this use case // &lt;cstdint&gt; types are superior for this use case
// unaligned big endian signed integer types // unaligned big endian signed integer types
typedef endian&lt;order::big, int_least8_t, 8&gt; big_int8un_t; typedef endian&lt;order::big, int_least8_t, 8&gt; big_int8_t;
typedef endian&lt;order::big, int_least16_t, 16&gt; big_int16un_t; typedef endian&lt;order::big, int_least16_t, 16&gt; big_int16_t;
typedef endian&lt;order::big, int_least32_t, 24&gt; big_int24un_t; typedef endian&lt;order::big, int_least32_t, 24&gt; big_int24_t;
typedef endian&lt;order::big, int_least32_t, 32&gt; big_int32un_t; typedef endian&lt;order::big, int_least32_t, 32&gt; big_int32_t;
typedef endian&lt;order::big, int_least64_t, 40&gt; big_int40un_t; typedef endian&lt;order::big, int_least64_t, 40&gt; big_int40_t;
typedef endian&lt;order::big, int_least64_t, 48&gt; big_int48un_t; typedef endian&lt;order::big, int_least64_t, 48&gt; big_int48_t;
typedef endian&lt;order::big, int_least64_t, 56&gt; big_int56un_t; typedef endian&lt;order::big, int_least64_t, 56&gt; big_int56_t;
typedef endian&lt;order::big, int_least64_t, 64&gt; big_int64un_t; typedef endian&lt;order::big, int_least64_t, 64&gt; big_int64_t;
// unaligned big endian unsigned integer types // unaligned big endian unsigned integer types
typedef endian&lt;order::big, uint_least8_t, 8&gt; big_uint8un_t; typedef endian&lt;order::big, uint_least8_t, 8&gt; big_uint8_t;
typedef endian&lt;order::big, uint_least16_t, 16&gt; big_uint16un_t; typedef endian&lt;order::big, uint_least16_t, 16&gt; big_uint16_t;
typedef endian&lt;order::big, uint_least32_t, 24&gt; big_uint24un_t; typedef endian&lt;order::big, uint_least32_t, 24&gt; big_uint24_t;
typedef endian&lt;order::big, uint_least32_t, 32&gt; big_uint32un_t; typedef endian&lt;order::big, uint_least32_t, 32&gt; big_uint32_t;
typedef endian&lt;order::big, uint_least64_t, 40&gt; big_uint40un_t; typedef endian&lt;order::big, uint_least64_t, 40&gt; big_uint40_t;
typedef endian&lt;order::big, uint_least64_t, 48&gt; big_uint48un_t; typedef endian&lt;order::big, uint_least64_t, 48&gt; big_uint48_t;
typedef endian&lt;order::big, uint_least64_t, 56&gt; big_uint56un_t; typedef endian&lt;order::big, uint_least64_t, 56&gt; big_uint56_t;
typedef endian&lt;order::big, uint_least64_t, 64&gt; big_uint64un_t; typedef endian&lt;order::big, uint_least64_t, 64&gt; big_uint64_t;
// unaligned little endian signed integer types // unaligned little endian signed integer types
typedef endian&lt;order::little, int_least8_t, 8&gt; little_int8un_t; typedef endian&lt;order::little, int_least8_t, 8&gt; little_int8_t;
typedef endian&lt;order::little, int_least16_t, 16&gt; little_int16un_t; typedef endian&lt;order::little, int_least16_t, 16&gt; little_int16_t;
typedef endian&lt;order::little, int_least32_t, 24&gt; little_int24un_t; typedef endian&lt;order::little, int_least32_t, 24&gt; little_int24_t;
typedef endian&lt;order::little, int_least32_t, 32&gt; little_int32un_t; typedef endian&lt;order::little, int_least32_t, 32&gt; little_int32_t;
typedef endian&lt;order::little, int_least64_t, 40&gt; little_int40un_t; typedef endian&lt;order::little, int_least64_t, 40&gt; little_int40_t;
typedef endian&lt;order::little, int_least64_t, 48&gt; little_int48un_t; typedef endian&lt;order::little, int_least64_t, 48&gt; little_int48_t;
typedef endian&lt;order::little, int_least64_t, 56&gt; little_int56un_t; typedef endian&lt;order::little, int_least64_t, 56&gt; little_int56_t;
typedef endian&lt;order::little, int_least64_t, 64&gt; little_int64un_t; typedef endian&lt;order::little, int_least64_t, 64&gt; little_int64_t;
// unaligned little endian unsigned integer types // unaligned little endian unsigned integer types
typedef endian&lt;order::little, uint_least8_t, 8&gt; little_uint8un_t; typedef endian&lt;order::little, uint_least8_t, 8&gt; little_uint8_t;
typedef endian&lt;order::little, uint_least16_t, 16&gt; little_uint16un_t; typedef endian&lt;order::little, uint_least16_t, 16&gt; little_uint16_t;
typedef endian&lt;order::little, uint_least32_t, 24&gt; little_uint24un_t; typedef endian&lt;order::little, uint_least32_t, 24&gt; little_uint24_t;
typedef endian&lt;order::little, uint_least32_t, 32&gt; little_uint32un_t; typedef endian&lt;order::little, uint_least32_t, 32&gt; little_uint32_t;
typedef endian&lt;order::little, uint_least64_t, 40&gt; little_uint40un_t; typedef endian&lt;order::little, uint_least64_t, 40&gt; little_uint40_t;
typedef endian&lt;order::little, uint_least64_t, 48&gt; little_uint48un_t; typedef endian&lt;order::little, uint_least64_t, 48&gt; little_uint48_t;
typedef endian&lt;order::little, uint_least64_t, 56&gt; little_uint56un_t; typedef endian&lt;order::little, uint_least64_t, 56&gt; little_uint56_t;
typedef endian&lt;order::little, uint_least64_t, 64&gt; little_uint64un_t; typedef endian&lt;order::little, uint_least64_t, 64&gt; little_uint64_t;
// unaligned native endian signed integer types // unaligned native endian signed integer types
typedef endian&lt;order::native, int_least8_t, 8&gt; native_int8un_t; typedef endian&lt;order::native, int_least8_t, 8&gt; native_int8_t;
typedef endian&lt;order::native, int_least16_t, 16&gt; native_int16un_t; typedef endian&lt;order::native, int_least16_t, 16&gt; native_int16_t;
typedef endian&lt;order::native, int_least32_t, 24&gt; native_int24un_t; typedef endian&lt;order::native, int_least32_t, 24&gt; native_int24_t;
typedef endian&lt;order::native, int_least32_t, 32&gt; native_int32un_t; typedef endian&lt;order::native, int_least32_t, 32&gt; native_int32_t;
typedef endian&lt;order::native, int_least64_t, 40&gt; native_int40un_t; typedef endian&lt;order::native, int_least64_t, 40&gt; native_int40_t;
typedef endian&lt;order::native, int_least64_t, 48&gt; native_int48un_t; typedef endian&lt;order::native, int_least64_t, 48&gt; native_int48_t;
typedef endian&lt;order::native, int_least64_t, 56&gt; native_int56un_t; typedef endian&lt;order::native, int_least64_t, 56&gt; native_int56_t;
typedef endian&lt;order::native, int_least64_t, 64&gt; native_int64un_t; typedef endian&lt;order::native, int_least64_t, 64&gt; native_int64_t;
// unaligned native endian unsigned integer types // unaligned native endian unsigned integer types
typedef endian&lt;order::native, uint_least8_t, 8&gt; native_uint8un_t; typedef endian&lt;order::native, uint_least8_t, 8&gt; native_uint8_t;
typedef endian&lt;order::native, uint_least16_t, 16&gt; native_uint16un_t; typedef endian&lt;order::native, uint_least16_t, 16&gt; native_uint16_t;
typedef endian&lt;order::native, uint_least32_t, 24&gt; native_uint24un_t; typedef endian&lt;order::native, uint_least32_t, 24&gt; native_uint24_t;
typedef endian&lt;order::native, uint_least32_t, 32&gt; native_uint32un_t; typedef endian&lt;order::native, uint_least32_t, 32&gt; native_uint32_t;
typedef endian&lt;order::native, uint_least64_t, 40&gt; native_uint40un_t; typedef endian&lt;order::native, uint_least64_t, 40&gt; native_uint40_t;
typedef endian&lt;order::native, uint_least64_t, 48&gt; native_uint48un_t; typedef endian&lt;order::native, uint_least64_t, 48&gt; native_uint48_t;
typedef endian&lt;order::native, uint_least64_t, 56&gt; native_uint56un_t; typedef endian&lt;order::native, uint_least64_t, 56&gt; native_uint56_t;
typedef endian&lt;order::native, uint_least64_t, 64&gt; native_uint64un_t; typedef endian&lt;order::native, uint_least64_t, 64&gt; native_uint64_t;
} // namespace endian } // namespace endian
} // namespace boost</pre> } // namespace boost</pre>
@@ -617,7 +617,7 @@ differs from endian representation size. Vicente Botet and other reviewers
suggested supporting floating point types.</p> suggested supporting floating point types.</p>
<hr> <hr>
<p>Last revised: <p>Last revised:
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->30 May, 2013<!--webbot bot="Timestamp" endspan i-checksum="13977" --></p> <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->31 August, 2013<!--webbot bot="Timestamp" endspan i-checksum="34505" --></p>
<p>© Copyright Beman Dawes, 2006-2009, 2013</p> <p>© Copyright Beman Dawes, 2006-2009, 2013</p>
<p>Distributed under the Boost Software License, Version 1.0. See <p>Distributed under the Boost Software License, Version 1.0. See
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/ LICENSE_1_0.txt</a></p> <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/ LICENSE_1_0.txt</a></p>

2
include/boost/endian/conversion.hpp
View File

@@ -128,7 +128,7 @@ namespace endian
namespace detail namespace detail
// These functions are unsafe for general use, so is placed in namespace detail. // These functions are unsafe for general use, so is placed in namespace detail.
// Think of what happens if you reverse_value a std::pair<int16_t, int_int16un_t>; the bytes // Think of what happens if you reverse_value a std::pair<int16_t, int_int16_t>; the bytes
// from first end up in second and the bytes from second end up in first. Not good! // from first end up in second and the bytes from second end up in first. Not good!
{ {
// general reverse_value function template useful in testing // general reverse_value function template useful in testing

136
include/boost/endian/types.hpp
View File

@@ -81,103 +81,103 @@ namespace endian
class endian; class endian;
// aligned big endian floating point types // aligned big endian floating point types
typedef endian<order::big, float, 32, align::yes> big_float32_t; typedef endian<order::big, float, 32, align::yes> big_align_float32_t;
typedef endian<order::big, double, 64, align::yes> big_float64_t; typedef endian<order::big, double, 64, align::yes> big_align_float64_t;
// aligned little endian floating point types // aligned little endian floating point types
typedef endian<order::little, float, 32, align::yes> little_float32_t; typedef endian<order::little, float, 32, align::yes> little_align_float32_t;
typedef endian<order::little, double, 64, align::yes> little_float64_t; typedef endian<order::little, double, 64, align::yes> little_align_float64_t;
// unaligned big endian floating point types // unaligned big endian floating point types
typedef endian<order::big, float, 32, align::no> big_float32un_t; typedef endian<order::big, float, 32, align::no> big_float32_t;
typedef endian<order::big, double, 64, align::no> big_float64un_t; typedef endian<order::big, double, 64, align::no> big_float64_t;
// unaligned little endian floating point types // unaligned little endian floating point types
typedef endian<order::little, float, 32, align::no> little_float32un_t; typedef endian<order::little, float, 32, align::no> little_float32_t;
typedef endian<order::little, double, 64, align::no> little_float64un_t; typedef endian<order::little, double, 64, align::no> little_float64_t;
// aligned big endian signed integer types // aligned big endian signed integer types
typedef endian<order::big, int16_t, 16, align::yes> big_int16_t; typedef endian<order::big, int16_t, 16, align::yes> big_align_int16_t;
typedef endian<order::big, int32_t, 32, align::yes> big_int32_t; typedef endian<order::big, int32_t, 32, align::yes> big_align_int32_t;
typedef endian<order::big, int64_t, 64, align::yes> big_int64_t; typedef endian<order::big, int64_t, 64, align::yes> big_align_int64_t;
// aligned big endian unsigned integer types // aligned big endian unsigned integer types
typedef endian<order::big, uint16_t, 16, align::yes> big_uint16_t; typedef endian<order::big, uint16_t, 16, align::yes> big_align_uint16_t;
typedef endian<order::big, uint32_t, 32, align::yes> big_uint32_t; typedef endian<order::big, uint32_t, 32, align::yes> big_align_uint32_t;
typedef endian<order::big, uint64_t, 64, align::yes> big_uint64_t; typedef endian<order::big, uint64_t, 64, align::yes> big_align_uint64_t;
// aligned little endian signed integer types // aligned little endian signed integer types
typedef endian<order::little, int16_t, 16, align::yes> little_int16_t; typedef endian<order::little, int16_t, 16, align::yes> little_align_int16_t;
typedef endian<order::little, int32_t, 32, align::yes> little_int32_t; typedef endian<order::little, int32_t, 32, align::yes> little_align_int32_t;
typedef endian<order::little, int64_t, 64, align::yes> little_int64_t; typedef endian<order::little, int64_t, 64, align::yes> little_align_int64_t;
// aligned little endian unsigned integer types // aligned little endian unsigned integer types
typedef endian<order::little, uint16_t, 16, align::yes> little_uint16_t; typedef endian<order::little, uint16_t, 16, align::yes> little_align_uint16_t;
typedef endian<order::little, uint32_t, 32, align::yes> little_uint32_t; typedef endian<order::little, uint32_t, 32, align::yes> little_align_uint32_t;
typedef endian<order::little, uint64_t, 64, align::yes> little_uint64_t; typedef endian<order::little, uint64_t, 64, align::yes> little_align_uint64_t;
// aligned native endian typedefs are not provided because // aligned native endian typedefs are not provided because
// <cstdint> types are superior for this use case // <cstdint> types are superior for this use case
// unaligned big endian signed integer types // unaligned big endian signed integer types
typedef endian<order::big, int_least8_t, 8> big_int8un_t; typedef endian<order::big, int_least8_t, 8> big_int8_t;
typedef endian<order::big, int_least16_t, 16> big_int16un_t; typedef endian<order::big, int_least16_t, 16> big_int16_t;
typedef endian<order::big, int_least32_t, 24> big_int24un_t; typedef endian<order::big, int_least32_t, 24> big_int24_t;
typedef endian<order::big, int_least32_t, 32> big_int32un_t; typedef endian<order::big, int_least32_t, 32> big_int32_t;
typedef endian<order::big, int_least64_t, 40> big_int40un_t; typedef endian<order::big, int_least64_t, 40> big_int40_t;
typedef endian<order::big, int_least64_t, 48> big_int48un_t; typedef endian<order::big, int_least64_t, 48> big_int48_t;
typedef endian<order::big, int_least64_t, 56> big_int56un_t; typedef endian<order::big, int_least64_t, 56> big_int56_t;
typedef endian<order::big, int_least64_t, 64> big_int64un_t; typedef endian<order::big, int_least64_t, 64> big_int64_t;
// unaligned big endian unsigned integer types // unaligned big endian unsigned integer types
typedef endian<order::big, uint_least8_t, 8> big_uint8un_t; typedef endian<order::big, uint_least8_t, 8> big_uint8_t;
typedef endian<order::big, uint_least16_t, 16> big_uint16un_t; typedef endian<order::big, uint_least16_t, 16> big_uint16_t;
typedef endian<order::big, uint_least32_t, 24> big_uint24un_t; typedef endian<order::big, uint_least32_t, 24> big_uint24_t;
typedef endian<order::big, uint_least32_t, 32> big_uint32un_t; typedef endian<order::big, uint_least32_t, 32> big_uint32_t;
typedef endian<order::big, uint_least64_t, 40> big_uint40un_t; typedef endian<order::big, uint_least64_t, 40> big_uint40_t;
typedef endian<order::big, uint_least64_t, 48> big_uint48un_t; typedef endian<order::big, uint_least64_t, 48> big_uint48_t;
typedef endian<order::big, uint_least64_t, 56> big_uint56un_t; typedef endian<order::big, uint_least64_t, 56> big_uint56_t;
typedef endian<order::big, uint_least64_t, 64> big_uint64un_t; typedef endian<order::big, uint_least64_t, 64> big_uint64_t;
// unaligned little endian signed integer types // unaligned little endian signed integer types
typedef endian<order::little, int_least8_t, 8> little_int8un_t; typedef endian<order::little, int_least8_t, 8> little_int8_t;
typedef endian<order::little, int_least16_t, 16> little_int16un_t; typedef endian<order::little, int_least16_t, 16> little_int16_t;
typedef endian<order::little, int_least32_t, 24> little_int24un_t; typedef endian<order::little, int_least32_t, 24> little_int24_t;
typedef endian<order::little, int_least32_t, 32> little_int32un_t; typedef endian<order::little, int_least32_t, 32> little_int32_t;
typedef endian<order::little, int_least64_t, 40> little_int40un_t; typedef endian<order::little, int_least64_t, 40> little_int40_t;
typedef endian<order::little, int_least64_t, 48> little_int48un_t; typedef endian<order::little, int_least64_t, 48> little_int48_t;
typedef endian<order::little, int_least64_t, 56> little_int56un_t; typedef endian<order::little, int_least64_t, 56> little_int56_t;
typedef endian<order::little, int_least64_t, 64> little_int64un_t; typedef endian<order::little, int_least64_t, 64> little_int64_t;
// unaligned little endian unsigned integer types // unaligned little endian unsigned integer types
typedef endian<order::little, uint_least8_t, 8> little_uint8un_t; typedef endian<order::little, uint_least8_t, 8> little_uint8_t;
typedef endian<order::little, uint_least16_t, 16> little_uint16un_t; typedef endian<order::little, uint_least16_t, 16> little_uint16_t;
typedef endian<order::little, uint_least32_t, 24> little_uint24un_t; typedef endian<order::little, uint_least32_t, 24> little_uint24_t;
typedef endian<order::little, uint_least32_t, 32> little_uint32un_t; typedef endian<order::little, uint_least32_t, 32> little_uint32_t;
typedef endian<order::little, uint_least64_t, 40> little_uint40un_t; typedef endian<order::little, uint_least64_t, 40> little_uint40_t;
typedef endian<order::little, uint_least64_t, 48> little_uint48un_t; typedef endian<order::little, uint_least64_t, 48> little_uint48_t;
typedef endian<order::little, uint_least64_t, 56> little_uint56un_t; typedef endian<order::little, uint_least64_t, 56> little_uint56_t;
typedef endian<order::little, uint_least64_t, 64> little_uint64un_t; typedef endian<order::little, uint_least64_t, 64> little_uint64_t;
// unaligned native endian signed integer types // unaligned native endian signed integer types
typedef endian<order::native, int_least8_t, 8> native_int8un_t; typedef endian<order::native, int_least8_t, 8> native_int8_t;
typedef endian<order::native, int_least16_t, 16> native_int16un_t; typedef endian<order::native, int_least16_t, 16> native_int16_t;
typedef endian<order::native, int_least32_t, 24> native_int24un_t; typedef endian<order::native, int_least32_t, 24> native_int24_t;
typedef endian<order::native, int_least32_t, 32> native_int32un_t; typedef endian<order::native, int_least32_t, 32> native_int32_t;
typedef endian<order::native, int_least64_t, 40> native_int40un_t; typedef endian<order::native, int_least64_t, 40> native_int40_t;
typedef endian<order::native, int_least64_t, 48> native_int48un_t; typedef endian<order::native, int_least64_t, 48> native_int48_t;
typedef endian<order::native, int_least64_t, 56> native_int56un_t; typedef endian<order::native, int_least64_t, 56> native_int56_t;
typedef endian<order::native, int_least64_t, 64> native_int64un_t; typedef endian<order::native, int_least64_t, 64> native_int64_t;
// unaligned native endian unsigned integer types // unaligned native endian unsigned integer types
typedef endian<order::native, uint_least8_t, 8> native_uint8un_t; typedef endian<order::native, uint_least8_t, 8> native_uint8_t;
typedef endian<order::native, uint_least16_t, 16> native_uint16un_t; typedef endian<order::native, uint_least16_t, 16> native_uint16_t;
typedef endian<order::native, uint_least32_t, 24> native_uint24un_t; typedef endian<order::native, uint_least32_t, 24> native_uint24_t;
typedef endian<order::native, uint_least32_t, 32> native_uint32un_t; typedef endian<order::native, uint_least32_t, 32> native_uint32_t;
typedef endian<order::native, uint_least64_t, 40> native_uint40un_t; typedef endian<order::native, uint_least64_t, 40> native_uint40_t;
typedef endian<order::native, uint_least64_t, 48> native_uint48un_t; typedef endian<order::native, uint_least64_t, 48> native_uint48_t;
typedef endian<order::native, uint_least64_t, 56> native_uint56un_t; typedef endian<order::native, uint_least64_t, 56> native_uint56_t;
typedef endian<order::native, uint_least64_t, 64> native_uint64un_t; typedef endian<order::native, uint_least64_t, 64> native_uint64_t;
} // namespace boost } // namespace boost
} // namespace endian } // namespace endian

96
test/endian_in_union_test.cpp
View File

@@ -23,59 +23,59 @@ using namespace boost::endian;
union U union U
{ {
big_int8un_t big_8; big_int8_t big_8;
big_int16un_t big_16; big_int16_t big_16;
big_int24un_t big_24; big_int24_t big_24;
big_int32un_t big_32; big_int32_t big_32;
big_int40un_t big_40; big_int40_t big_40;
big_int48un_t big_48; big_int48_t big_48;
big_int56un_t big_56; big_int56_t big_56;
big_int64un_t big_64; big_int64_t big_64;
big_uint8un_t big_u8; big_uint8_t big_u8;
big_uint16un_t big_u16; big_uint16_t big_u16;
big_uint24un_t big_u24; big_uint24_t big_u24;
big_uint32un_t big_u32; big_uint32_t big_u32;
big_uint40un_t big_u40; big_uint40_t big_u40;
big_uint48un_t big_u48; big_uint48_t big_u48;
big_uint56un_t big_u56; big_uint56_t big_u56;
big_uint64un_t big_u64; big_uint64_t big_u64;
little_int8un_t little_8; little_int8_t little_8;
little_int16un_t little_16; little_int16_t little_16;
little_int24un_t little_24; little_int24_t little_24;
little_int32un_t little_32; little_int32_t little_32;
little_int40un_t little_40; little_int40_t little_40;
little_int48un_t little_48; little_int48_t little_48;
little_int56un_t little_56; little_int56_t little_56;
little_int64un_t little_64; little_int64_t little_64;
little_uint8un_t little_u8; little_uint8_t little_u8;
little_uint16un_t little_u16; little_uint16_t little_u16;
little_uint24un_t little_u24; little_uint24_t little_u24;
little_uint32un_t little_u32; little_uint32_t little_u32;
little_uint40un_t little_u40; little_uint40_t little_u40;
little_uint48un_t little_u48; little_uint48_t little_u48;
little_uint56un_t little_u56; little_uint56_t little_u56;
little_uint64un_t little_u64; little_uint64_t little_u64;
native_int8un_t native_8; native_int8_t native_8;
native_int16un_t native_16; native_int16_t native_16;
native_int24un_t native_24; native_int24_t native_24;
native_int32un_t native_32; native_int32_t native_32;
native_int40un_t native_40; native_int40_t native_40;
native_int48un_t native_48; native_int48_t native_48;
native_int56un_t native_56; native_int56_t native_56;
native_int64un_t native_64; native_int64_t native_64;
native_uint8un_t native_u8; native_uint8_t native_u8;
native_uint16un_t native_u16; native_uint16_t native_u16;
native_uint24un_t native_u24; native_uint24_t native_u24;
native_uint32un_t native_u32; native_uint32_t native_u32;
native_uint40un_t native_u40; native_uint40_t native_u40;
native_uint48un_t native_u48; native_uint48_t native_u48;
native_uint56un_t native_u56; native_uint56_t native_u56;
native_uint64un_t native_u64; native_uint64_t native_u64;
}; };
U foo; U foo;

224
test/endian_operations_test.cpp
View File

@@ -205,67 +205,67 @@ void op_test_aux()
Test<T1, unsigned long>::test(); Test<T1, unsigned long>::test();
Test<T1, long long>::test(); Test<T1, long long>::test();
Test<T1, unsigned long long>::test(); Test<T1, unsigned long long>::test();
Test<T1, be::big_align_int16_t>::test();
Test<T1, be::big_align_int32_t>::test();
Test<T1, be::big_align_int64_t>::test();
Test<T1, be::big_align_uint16_t>::test();
Test<T1, be::big_align_uint32_t>::test();
Test<T1, be::big_align_uint64_t>::test();
Test<T1, be::little_align_int16_t>::test();
Test<T1, be::little_align_int32_t>::test();
Test<T1, be::little_align_int64_t>::test();
Test<T1, be::little_align_uint16_t>::test();
Test<T1, be::little_align_uint32_t>::test();
Test<T1, be::little_align_uint64_t>::test();
Test<T1, be::big_int8_t>::test();
Test<T1, be::big_int16_t>::test(); Test<T1, be::big_int16_t>::test();
Test<T1, be::big_int24_t>::test();
Test<T1, be::big_int32_t>::test(); Test<T1, be::big_int32_t>::test();
Test<T1, be::big_int40_t>::test();
Test<T1, be::big_int48_t>::test();
Test<T1, be::big_int56_t>::test();
Test<T1, be::big_int64_t>::test(); Test<T1, be::big_int64_t>::test();
Test<T1, be::big_uint8_t>::test();
Test<T1, be::big_uint16_t>::test(); Test<T1, be::big_uint16_t>::test();
Test<T1, be::big_uint24_t>::test();
Test<T1, be::big_uint32_t>::test(); Test<T1, be::big_uint32_t>::test();
Test<T1, be::big_uint40_t>::test();
Test<T1, be::big_uint64_t>::test(); Test<T1, be::big_uint64_t>::test();
Test<T1, be::little_int16_t>::test(); Test<T1, be::little_int16_t>::test();
Test<T1, be::little_int24_t>::test();
Test<T1, be::little_int32_t>::test(); Test<T1, be::little_int32_t>::test();
Test<T1, be::little_int64_t>::test(); Test<T1, be::little_int64_t>::test();
Test<T1, be::little_uint16_t>::test(); Test<T1, be::little_uint16_t>::test();
Test<T1, be::little_uint32_t>::test(); Test<T1, be::little_uint32_t>::test();
Test<T1, be::little_uint56_t>::test();
Test<T1, be::little_uint64_t>::test(); Test<T1, be::little_uint64_t>::test();
Test<T1, be::big_int8un_t>::test(); Test<T1, be::native_int16_t>::test();
Test<T1, be::big_int16un_t>::test(); Test<T1, be::native_int24_t>::test();
Test<T1, be::big_int24un_t>::test(); Test<T1, be::native_int32_t>::test();
Test<T1, be::big_int32un_t>::test(); Test<T1, be::native_int64_t>::test();
Test<T1, be::big_int40un_t>::test();
Test<T1, be::big_int48un_t>::test();
Test<T1, be::big_int56un_t>::test();
Test<T1, be::big_int64un_t>::test();
Test<T1, be::big_uint8un_t>::test();
Test<T1, be::big_uint16un_t>::test();
Test<T1, be::big_uint24un_t>::test();
Test<T1, be::big_uint32un_t>::test();
Test<T1, be::big_uint40un_t>::test();
Test<T1, be::big_uint64un_t>::test();
Test<T1, be::little_int16un_t>::test();
Test<T1, be::little_int24un_t>::test();
Test<T1, be::little_int32un_t>::test();
Test<T1, be::little_int64un_t>::test();
Test<T1, be::little_uint16un_t>::test();
Test<T1, be::little_uint32un_t>::test();
Test<T1, be::little_uint56un_t>::test();
Test<T1, be::little_uint64un_t>::test();
Test<T1, be::native_int16un_t>::test();
Test<T1, be::native_int24un_t>::test();
Test<T1, be::native_int32un_t>::test();
Test<T1, be::native_int64un_t>::test();
#ifdef BOOST_LONG_ENDIAN_TEST #ifdef BOOST_LONG_ENDIAN_TEST
Test<T1, be::native_uint16un_t>::test(); Test<T1, be::native_uint16_t>::test();
Test<T1, be::native_uint24un_t>::test(); Test<T1, be::native_uint24_t>::test();
Test<T1, be::native_uint32un_t>::test(); Test<T1, be::native_uint32_t>::test();
Test<T1, be::native_uint48un_t>::test(); Test<T1, be::native_uint48_t>::test();
Test<T1, be::native_uint64un_t>::test(); Test<T1, be::native_uint64_t>::test();
Test<T1, be::big_uint48un_t>::test(); Test<T1, be::big_uint48_t>::test();
Test<T1, be::big_uint56un_t>::test(); Test<T1, be::big_uint56_t>::test();
Test<T1, be::little_int8un_t>::test(); Test<T1, be::little_int8_t>::test();
Test<T1, be::little_int56un_t>::test(); Test<T1, be::little_int56_t>::test();
Test<T1, be::little_int40un_t>::test(); Test<T1, be::little_int40_t>::test();
Test<T1, be::little_int48un_t>::test(); Test<T1, be::little_int48_t>::test();
Test<T1, be::little_uint8un_t>::test(); Test<T1, be::little_uint8_t>::test();
Test<T1, be::little_uint24un_t>::test(); Test<T1, be::little_uint24_t>::test();
Test<T1, be::little_uint40un_t>::test(); Test<T1, be::little_uint40_t>::test();
Test<T1, be::little_uint48un_t>::test(); Test<T1, be::little_uint48_t>::test();
Test<T1, be::native_int8un_t>::test(); Test<T1, be::native_int8_t>::test();
Test<T1, be::native_int40un_t>::test(); Test<T1, be::native_int40_t>::test();
Test<T1, be::native_int48un_t>::test(); Test<T1, be::native_int48_t>::test();
Test<T1, be::native_int56un_t>::test(); Test<T1, be::native_int56_t>::test();
Test<T1, be::native_uint8un_t>::test(); Test<T1, be::native_uint8_t>::test();
Test<T1, be::native_uint40un_t>::test(); Test<T1, be::native_uint40_t>::test();
Test<T1, be::native_uint56un_t>::test(); Test<T1, be::native_uint56_t>::test();
#endif #endif
} }
@@ -283,61 +283,61 @@ void op_test()
op_test_aux<Test, unsigned long>(); op_test_aux<Test, unsigned long>();
op_test_aux<Test, long long>(); op_test_aux<Test, long long>();
op_test_aux<Test, unsigned long long>(); op_test_aux<Test, unsigned long long>();
op_test_aux<Test, be::big_int16_t>(); op_test_aux<Test, be::big_align_int16_t>();
op_test_aux<Test, be::big_int32_t>(); op_test_aux<Test, be::big_align_int32_t>();
op_test_aux<Test, be::big_int64_t>(); op_test_aux<Test, be::big_align_int64_t>();
op_test_aux<Test, be::little_int16_t>(); op_test_aux<Test, be::little_align_int16_t>();
op_test_aux<Test, be::little_int32_t>(); op_test_aux<Test, be::little_align_int32_t>();
op_test_aux<Test, be::little_int64_t>(); op_test_aux<Test, be::little_align_int64_t>();
#ifdef BOOST_LONG_ENDIAN_TEST #ifdef BOOST_LONG_ENDIAN_TEST
op_test_aux<Test, be::big_int8un_t>(); op_test_aux<Test, be::big_int8_t>();
op_test_aux<Test, be::big_int16un_t>(); op_test_aux<Test, be::big_int16_t>();
op_test_aux<Test, be::big_int24un_t>(); op_test_aux<Test, be::big_int24_t>();
op_test_aux<Test, be::big_int32un_t>(); op_test_aux<Test, be::big_int32_t>();
op_test_aux<Test, be::big_int40un_t>(); op_test_aux<Test, be::big_int40_t>();
op_test_aux<Test, be::big_int48un_t>(); op_test_aux<Test, be::big_int48_t>();
op_test_aux<Test, be::big_int56un_t>(); op_test_aux<Test, be::big_int56_t>();
op_test_aux<Test, be::big_int64un_t>(); op_test_aux<Test, be::big_int64_t>();
op_test_aux<Test, be::big_uint8un_t>(); op_test_aux<Test, be::big_uint8_t>();
op_test_aux<Test, be::big_uint16un_t>(); op_test_aux<Test, be::big_uint16_t>();
op_test_aux<Test, be::big_uint24un_t>(); op_test_aux<Test, be::big_uint24_t>();
op_test_aux<Test, be::big_uint32un_t>(); op_test_aux<Test, be::big_uint32_t>();
op_test_aux<Test, be::big_uint40un_t>(); op_test_aux<Test, be::big_uint40_t>();
op_test_aux<Test, be::big_uint48un_t>(); op_test_aux<Test, be::big_uint48_t>();
op_test_aux<Test, be::big_uint56un_t>(); op_test_aux<Test, be::big_uint56_t>();
op_test_aux<Test, be::big_uint64un_t>(); op_test_aux<Test, be::big_uint64_t>();
op_test_aux<Test, be::little_int8un_t>(); op_test_aux<Test, be::little_int8_t>();
op_test_aux<Test, be::little_int16un_t>(); op_test_aux<Test, be::little_int16_t>();
op_test_aux<Test, be::little_int24un_t>(); op_test_aux<Test, be::little_int24_t>();
op_test_aux<Test, be::little_int32un_t>(); op_test_aux<Test, be::little_int32_t>();
op_test_aux<Test, be::little_int40un_t>(); op_test_aux<Test, be::little_int40_t>();
op_test_aux<Test, be::little_int48un_t>(); op_test_aux<Test, be::little_int48_t>();
op_test_aux<Test, be::little_int56un_t>(); op_test_aux<Test, be::little_int56_t>();
op_test_aux<Test, be::little_int64un_t>(); op_test_aux<Test, be::little_int64_t>();
op_test_aux<Test, be::little_uint8un_t>(); op_test_aux<Test, be::little_uint8_t>();
op_test_aux<Test, be::little_uint16un_t>(); op_test_aux<Test, be::little_uint16_t>();
op_test_aux<Test, be::little_uint24un_t>(); op_test_aux<Test, be::little_uint24_t>();
op_test_aux<Test, be::little_uint32un_t>(); op_test_aux<Test, be::little_uint32_t>();
op_test_aux<Test, be::little_uint40un_t>(); op_test_aux<Test, be::little_uint40_t>();
op_test_aux<Test, be::little_uint48un_t>(); op_test_aux<Test, be::little_uint48_t>();
op_test_aux<Test, be::little_uint56un_t>(); op_test_aux<Test, be::little_uint56_t>();
op_test_aux<Test, be::little_uint64un_t>(); op_test_aux<Test, be::little_uint64_t>();
op_test_aux<Test, be::native_int8un_t>(); op_test_aux<Test, be::native_int8_t>();
op_test_aux<Test, be::native_int16un_t>(); op_test_aux<Test, be::native_int16_t>();
op_test_aux<Test, be::native_int24un_t>(); op_test_aux<Test, be::native_int24_t>();
op_test_aux<Test, be::native_int32un_t>(); op_test_aux<Test, be::native_int32_t>();
op_test_aux<Test, be::native_int40un_t>(); op_test_aux<Test, be::native_int40_t>();
op_test_aux<Test, be::native_int48un_t>(); op_test_aux<Test, be::native_int48_t>();
op_test_aux<Test, be::native_int56un_t>(); op_test_aux<Test, be::native_int56_t>();
op_test_aux<Test, be::native_int64un_t>(); op_test_aux<Test, be::native_int64_t>();
op_test_aux<Test, be::native_uint8un_t>(); op_test_aux<Test, be::native_uint8_t>();
op_test_aux<Test, be::native_uint16un_t>(); op_test_aux<Test, be::native_uint16_t>();
op_test_aux<Test, be::native_uint24un_t>(); op_test_aux<Test, be::native_uint24_t>();
op_test_aux<Test, be::native_uint32un_t>(); op_test_aux<Test, be::native_uint32_t>();
op_test_aux<Test, be::native_uint40un_t>(); op_test_aux<Test, be::native_uint40_t>();
op_test_aux<Test, be::native_uint48un_t>(); op_test_aux<Test, be::native_uint48_t>();
op_test_aux<Test, be::native_uint56un_t>(); op_test_aux<Test, be::native_uint56_t>();
op_test_aux<Test, be::native_uint64un_t>(); op_test_aux<Test, be::native_uint64_t>();
#endif #endif
} }
@@ -349,10 +349,10 @@ int cpp_main(int, char * [])
// make sure some simple things work // make sure some simple things work
be::big_int32un_t o1(1); be::big_int32_t o1(1);
be::big_int32un_t o2(2L); be::big_int32_t o2(2L);
be::big_int32un_t o3(3LL); be::big_int32_t o3(3LL);
be::big_int64un_t o4(1); be::big_int64_t o4(1);
// use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on // use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on
// what overloads and conversions are actually being performed. // what overloads and conversions are actually being performed.
@@ -360,9 +360,9 @@ int cpp_main(int, char * [])
be::endian_log = true; be::endian_log = true;
std::clog << "set up test values\n"; std::clog << "set up test values\n";
be::big_int32un_t big(12345); be::big_int32_t big(12345);
be::little_uint16un_t little_u(10); be::little_uint16_t little_u(10);
be::big_int64un_t result; be::big_int64_t result;
std::clog << "\nresult = +big\n"; std::clog << "\nresult = +big\n";
@@ -421,15 +421,15 @@ int cpp_main(int, char * [])
// test from Roland Schwarz that detected ambiguities // test from Roland Schwarz that detected ambiguities
unsigned u; unsigned u;
be::little_uint32un_t u1; be::little_uint32_t u1;
be::little_uint32un_t u2; be::little_uint32_t u2;
u = 1; u = 1;
u1 = 1; u1 = 1;
u2 = u1 + u; u2 = u1 + u;
// one more wrinkle // one more wrinkle
be::little_uint16un_t u3(3); be::little_uint16_t u3(3);
u3 = 3; u3 = 3;
u2 = u1 + u3; u2 = u1 + u3;

800
test/endian_test.cpp
View File

File diff suppressed because it is too large Load Diff

76
test/loop_time_test.cpp
View File

@@ -116,87 +116,87 @@ namespace
} }
void test_big_int16() void test_big_align_int16()
{ {
cout << "<tr><td>16-bit aligned big endian</td>"; cout << "<tr><td>16-bit aligned big endian</td>";
time<int16_t, big_align_int16_t>();
cout << "</tr>\n";
}
void test_little_align_int16()
{
cout << "<tr><td>16-bit aligned little endian</td>";
time<int16_t, little_align_int16_t>();
cout << "</tr>\n";
}
void test_big_int16()
{
cout << "<tr><td>16-bit unaligned big endian</td>";
time<int16_t, big_int16_t>(); time<int16_t, big_int16_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int16() void test_little_int16()
{ {
cout << "<tr><td>16-bit aligned little endian</td>"; cout << "<tr><td>16-bit unaligned little endian</td>";
time<int16_t, little_int16_t>(); time<int16_t, little_int16_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int16un() void test_big_align_int32()
{ {
cout << "<tr><td>16-bit unaligned big endian</td>"; cout << "<tr><td>32-bit aligned big endian</td>";
time<int16_t, big_int16un_t>(); time<int32_t, big_align_int32_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int16un() void test_little_align_int32()
{ {
cout << "<tr><td>16-bit unaligned little endian</td>"; cout << "<tr><td>32-bit aligned little endian</td>";
time<int16_t, little_int16un_t>(); time<int32_t, little_align_int32_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int32() void test_big_int32()
{ {
cout << "<tr><td>32-bit aligned big endian</td>"; cout << "<tr><td>32-bit unaligned big endian</td>";
time<int32_t, big_int32_t>(); time<int32_t, big_int32_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int32() void test_little_int32()
{ {
cout << "<tr><td>32-bit aligned little endian</td>"; cout << "<tr><td>32-bit unaligned little endian</td>";
time<int32_t, little_int32_t>(); time<int32_t, little_int32_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int32un() void test_big_align_int64()
{ {
cout << "<tr><td>32-bit unaligned big endian</td>"; cout << "<tr><td>64-bit aligned big endian</td>";
time<int32_t, big_int32un_t>(); time<int64_t, big_align_int64_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int32un() void test_little_align_int64()
{ {
cout << "<tr><td>32-bit unaligned little endian</td>"; cout << "<tr><td>64-bit aligned little endian</td>";
time<int32_t, little_int32un_t>(); time<int64_t, little_align_int64_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int64() void test_big_int64()
{ {
cout << "<tr><td>64-bit aligned big endian</td>"; cout << "<tr><td>64-bit unaligned big endian</td>";
time<int64_t, big_int64_t>(); time<int64_t, big_int64_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int64() void test_little_int64()
{
cout << "<tr><td>64-bit aligned little endian</td>";
time<int64_t, little_int64_t>();
cout << "</tr>\n";
}
void test_big_int64un()
{
cout << "<tr><td>64-bit unaligned big endian</td>";
time<int64_t, big_int64un_t>();
cout << "</tr>\n";
}
void test_little_int64un()
{ {
cout << "<tr><td>64-bit unaligned little endian</td>"; cout << "<tr><td>64-bit unaligned little endian</td>";
time<int64_t, little_int64un_t>(); time<int64_t, little_int64_t>();
cout << "</tr>\n"; cout << "</tr>\n";
} }
@@ -224,20 +224,20 @@ int cpp_main(int argc, char* argv[])
"</tr>\n" "</tr>\n"
; ;
test_big_align_int16();
test_little_align_int16();
test_big_int16(); test_big_int16();
test_little_int16(); test_little_int16();
test_big_int16un();
test_little_int16un();
test_big_align_int32();
test_little_align_int32();
test_big_int32(); test_big_int32();
test_little_int32(); test_little_int32();
test_big_int32un();
test_little_int32un();
test_big_align_int64();
test_little_align_int64();
test_big_int64(); test_big_int64();
test_little_int64(); test_little_int64();
test_big_int64un();
test_little_int64un();
cout << "\n</table>\n</body>\n</html>\n"; cout << "\n</table>\n</body>\n</html>\n";

72
test/speed_test.cpp
View File

@@ -96,63 +96,63 @@ namespace
cout << "<td align=\"right\">" << t.format(places, "%t") << " s</td>"; cout << "<td align=\"right\">" << t.format(places, "%t") << " s</td>";
} }
void test_big_int16() void test_big_align_int16()
{ {
cout << "<tr><td>16-bit aligned big endian</td>"; cout << "<tr><td>16-bit aligned big endian</td>";
time<int16_t, big_int16_t>(user::return_x_big_int16); time<int16_t, big_align_int16_t>(user::return_x_big_align_int16);
time<int16_t, big_int16_t>(user::return_x_value_big_int16); time<int16_t, big_align_int16_t>(user::return_x_value_big_align_int16);
time<int16_t, big_int16_t>(user::return_x_in_place_big_int16); time<int16_t, big_align_int16_t>(user::return_x_in_place_big_align_int16);
time<int16_t, big_int16_t>(user::return_x_big_int16); time<int16_t, big_align_int16_t>(user::return_x_big_align_int16);
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int16() void test_little_align_int16()
{ {
cout << "<tr><td>16-bit aligned little endian</td>"; cout << "<tr><td>16-bit aligned little endian</td>";
time<int16_t, little_int16_t>(user::return_x_little_int16); time<int16_t, little_align_int16_t>(user::return_x_little_align_int16);
time<int16_t, little_int16_t>(user::return_x_value_little_int16); time<int16_t, little_align_int16_t>(user::return_x_value_little_align_int16);
time<int16_t, little_int16_t>(user::return_x_in_place_little_int16); time<int16_t, little_align_int16_t>(user::return_x_in_place_little_align_int16);
time<int16_t, little_int16_t>(user::return_x_little_int16); time<int16_t, little_align_int16_t>(user::return_x_little_align_int16);
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int32() void test_big_align_int32()
{ {
cout << "<tr><td>32-bit aligned big endian</td>"; cout << "<tr><td>32-bit aligned big endian</td>";
time<int32_t, big_int32_t>(user::return_x_big_int32); time<int32_t, big_align_int32_t>(user::return_x_big_align_int32);
time<int32_t, big_int32_t>(user::return_x_value_big_int32); time<int32_t, big_align_int32_t>(user::return_x_value_big_align_int32);
time<int32_t, big_int32_t>(user::return_x_in_place_big_int32); time<int32_t, big_align_int32_t>(user::return_x_in_place_big_align_int32);
time<int32_t, big_int32_t>(user::return_x_big_int32); time<int32_t, big_align_int32_t>(user::return_x_big_align_int32);
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int32() void test_little_align_int32()
{ {
cout << "<tr><td>32-bit aligned little endian</td>"; cout << "<tr><td>32-bit aligned little endian</td>";
time<int32_t, little_int32_t>(user::return_x_little_int32); time<int32_t, little_align_int32_t>(user::return_x_little_align_int32);
time<int32_t, little_int32_t>(user::return_x_value_little_int32); time<int32_t, little_align_int32_t>(user::return_x_value_little_align_int32);
time<int32_t, little_int32_t>(user::return_x_in_place_little_int32); time<int32_t, little_align_int32_t>(user::return_x_in_place_little_align_int32);
time<int32_t, little_int32_t>(user::return_x_little_int32); time<int32_t, little_align_int32_t>(user::return_x_little_align_int32);
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_big_int64() void test_big_align_int64()
{ {
cout << "<tr><td>64-bit aligned big endian</td>"; cout << "<tr><td>64-bit aligned big endian</td>";
time<int64_t, big_int64_t>(user::return_x_big_int64); time<int64_t, big_align_int64_t>(user::return_x_big_align_int64);
time<int64_t, big_int64_t>(user::return_x_value_big_int64); time<int64_t, big_align_int64_t>(user::return_x_value_big_align_int64);
time<int64_t, big_int64_t>(user::return_x_in_place_big_int64); time<int64_t, big_align_int64_t>(user::return_x_in_place_big_align_int64);
time<int64_t, big_int64_t>(user::return_x_big_int64); time<int64_t, big_align_int64_t>(user::return_x_big_align_int64);
cout << "</tr>\n"; cout << "</tr>\n";
} }
void test_little_int64() void test_little_align_int64()
{ {
cout << "<tr><td>64-bit aligned little endian</td>"; cout << "<tr><td>64-bit aligned little endian</td>";
time<int64_t, little_int64_t>(user::return_x_little_int64); time<int64_t, little_align_int64_t>(user::return_x_little_align_int64);
time<int64_t, little_int64_t>(user::return_x_value_little_int64); time<int64_t, little_align_int64_t>(user::return_x_value_little_align_int64);
time<int64_t, little_int64_t>(user::return_x_in_place_little_int64); time<int64_t, little_align_int64_t>(user::return_x_in_place_little_align_int64);
time<int64_t, little_int64_t>(user::return_x_little_int64); time<int64_t, little_align_int64_t>(user::return_x_little_align_int64);
cout << "</tr>\n"; cout << "</tr>\n";
} }
@@ -182,12 +182,12 @@ int cpp_main(int argc, char* argv[])
"</tr>\n" "</tr>\n"
; ;
test_big_int16(); test_big_align_int16();
test_little_int16(); test_little_align_int16();
test_big_int32(); test_big_align_int32();
test_little_int32(); test_little_align_int32();
test_big_int64(); test_big_align_int64();
test_little_int64(); test_little_align_int64();
cout << "\n</table>\n</body>\n</html>\n"; cout << "\n</table>\n</body>\n</html>\n";

48
test/speed_test_functions.cpp
View File

@@ -20,31 +20,31 @@
namespace user namespace user
{ {
int16_t return_x_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {return x;} int16_t return_x_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {return x;}
int16_t return_x_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {return x;} int16_t return_x_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {return x;}
int16_t return_x_value_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {return big_endian_value(x);} int16_t return_x_value_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {return big_endian_value(x);}
int16_t return_x_value_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {return little_endian_value(x);} int16_t return_x_value_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {return little_endian_value(x);}
int16_t return_x_in_place_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT {big_endian(x);return x;} int16_t return_x_in_place_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT {big_endian(x);return x;}
int16_t return_x_in_place_little_int16(int16_t x, little_int16_t) BOOST_NOEXCEPT {little_endian(x);return x;} int16_t return_x_in_place_little_align_int16(int16_t x, little_align_int16_t) BOOST_NOEXCEPT {little_endian(x);return x;}
int16_t return_y_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT {return y;} int16_t return_y_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT {return y;}
int16_t return_y_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT {return y;} int16_t return_y_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT {return y;}
int32_t return_x_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {return x;} int32_t return_x_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {return x;}
int32_t return_x_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {return x;} int32_t return_x_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {return x;}
int32_t return_x_value_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {return big_endian_value(x);} int32_t return_x_value_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {return big_endian_value(x);}
int32_t return_x_value_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {return little_endian_value(x);} int32_t return_x_value_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {return little_endian_value(x);}
int32_t return_x_in_place_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT {big_endian(x);return x;} int32_t return_x_in_place_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT {big_endian(x);return x;}
int32_t return_x_in_place_little_int32(int32_t x, little_int32_t) BOOST_NOEXCEPT {little_endian(x);return x;} int32_t return_x_in_place_little_align_int32(int32_t x, little_align_int32_t) BOOST_NOEXCEPT {little_endian(x);return x;}
int32_t return_y_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT {return y;} int32_t return_y_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT {return y;}
int32_t return_y_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT {return y;} int32_t return_y_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT {return y;}
int64_t return_x_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {return x;} int64_t return_x_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {return x;}
int64_t return_x_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {return x;} int64_t return_x_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {return x;}
int64_t return_x_value_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {return big_endian_value(x);} int64_t return_x_value_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {return big_endian_value(x);}
int64_t return_x_value_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {return little_endian_value(x);} int64_t return_x_value_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {return little_endian_value(x);}
int64_t return_x_in_place_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT {big_endian(x);return x;} int64_t return_x_in_place_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT {big_endian(x);return x;}
int64_t return_x_in_place_little_int64(int64_t x, little_int64_t) BOOST_NOEXCEPT {little_endian(x);return x;} int64_t return_x_in_place_little_align_int64(int64_t x, little_align_int64_t) BOOST_NOEXCEPT {little_endian(x);return x;}
int64_t return_y_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT {return y;} int64_t return_y_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT {return y;}
int64_t return_y_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT {return y;} int64_t return_y_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT {return y;}
} }

48
test/speed_test_functions.hpp
View File

@@ -24,32 +24,32 @@ namespace user
using namespace boost; using namespace boost;
using namespace boost::endian; using namespace boost::endian;
int16_t return_x_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; int16_t return_x_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_x_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; int16_t return_x_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_x_value_big_int16(int16_t x, big_int16_t) BOOST_NOEXCEPT; int16_t return_x_value_big_align_int16(int16_t x, big_align_int16_t) BOOST_NOEXCEPT;
int16_t return_x_value_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; int16_t return_x_value_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_x_in_place_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; int16_t return_x_in_place_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_x_in_place_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; int16_t return_x_in_place_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_y_big_int16(int16_t x, big_int16_t y) BOOST_NOEXCEPT; int16_t return_y_big_align_int16(int16_t x, big_align_int16_t y) BOOST_NOEXCEPT;
int16_t return_y_little_int16(int16_t x, little_int16_t y) BOOST_NOEXCEPT; int16_t return_y_little_align_int16(int16_t x, little_align_int16_t y) BOOST_NOEXCEPT;
int32_t return_x_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; int32_t return_x_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_x_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; int32_t return_x_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_x_value_big_int32(int32_t x, big_int32_t) BOOST_NOEXCEPT; int32_t return_x_value_big_align_int32(int32_t x, big_align_int32_t) BOOST_NOEXCEPT;
int32_t return_x_value_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; int32_t return_x_value_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_x_in_place_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; int32_t return_x_in_place_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_x_in_place_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; int32_t return_x_in_place_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_y_big_int32(int32_t x, big_int32_t y) BOOST_NOEXCEPT; int32_t return_y_big_align_int32(int32_t x, big_align_int32_t y) BOOST_NOEXCEPT;
int32_t return_y_little_int32(int32_t x, little_int32_t y) BOOST_NOEXCEPT; int32_t return_y_little_align_int32(int32_t x, little_align_int32_t y) BOOST_NOEXCEPT;
int64_t return_x_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; int64_t return_x_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_x_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; int64_t return_x_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_x_value_big_int64(int64_t x, big_int64_t) BOOST_NOEXCEPT; int64_t return_x_value_big_align_int64(int64_t x, big_align_int64_t) BOOST_NOEXCEPT;
int64_t return_x_value_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; int64_t return_x_value_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_x_in_place_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; int64_t return_x_in_place_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_x_in_place_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; int64_t return_x_in_place_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_y_big_int64(int64_t x, big_int64_t y) BOOST_NOEXCEPT; int64_t return_y_big_align_int64(int64_t x, big_align_int64_t y) BOOST_NOEXCEPT;
int64_t return_y_little_int64(int64_t x, little_int64_t y) BOOST_NOEXCEPT; int64_t return_y_little_align_int64(int64_t x, little_align_int64_t y) BOOST_NOEXCEPT;
} }