From 84ad1a041feeee66e7c5e6484d706618bf4fb49c Mon Sep 17 00:00:00 2001 From: Beman Date: Wed, 13 Aug 2014 08:31:11 -0400 Subject: [PATCH] Merge develop --- README | 35 +++++ conversion.html | 42 +++--- index.html | 354 ++++++++++++++++++++++++++++++------------------ types.html | 133 +++++++++--------- 4 files changed, 350 insertions(+), 214 deletions(-) create mode 100644 README diff --git a/README b/README new file mode 100644 index 0000000..caa7377 --- /dev/null +++ b/README @@ -0,0 +1,35 @@ +Boost Endian library + +To experiment with the Endian library, various other boost libraries must be +available. So you need to clone or install a current version of Boost if you +have notalready done so. + +Boost.Endian is a header-only library, so there is no need to run a build +for it. These instructions do assume bootstrap has been run so that b2 is +in your path environmental variable. + +Windows +======= + + cd boost-root\libs + git clone git://github.com/Beman/endian.git + cd ..\boost + mklink /d endian ..\libs\endian\include\boost\endian + cd ..\libs\endian\test + b2 + +Others +====== + + cd boost-root/libs + git clone git://github.com/Beman/endian.git + cd ../boost + ln -s ../libs/endian/include/boost/endian endian + cd ../libs/endian/test + b2 + +--------------------------- +Copyright Beman Dawes, 2013 + +Distributed under the Boost Software License, Version 1.0. +http://www.boost.org/LICENSE_1_0.txt \ No newline at end of file diff --git a/conversion.html b/conversion.html index ae07043..bd5bfc4 100644 --- a/conversion.html +++ b/conversion.html @@ -88,26 +88,27 @@ namespace boost { namespace endian { - enum class order {big, little, native}; + enum class order + { + big, // big-endian + little, // little-endian + native = implementation-defined // same as order::big or order::little + }; // reverse byte order (i.e. endianness) + int8_t reverse_value(int8_t x) noexcept; int16_t reverse_value(int16_t x) noexcept; int32_t reverse_value(int32_t x) noexcept; int64_t reverse_value(int64_t x) noexcept; + uint8_t reverse_value(uint8_t x) noexcept; uint16_t reverse_value(uint16_t x) noexcept; uint32_t reverse_value(uint32_t x) noexcept; uint64_t reverse_value(uint64_t x) noexcept; float reverse_value(float x) noexcept; double reverse_value(double x) noexcept; - void reverse(int16_t& x) noexcept; - void reverse(int32_t& x) noexcept; - void reverse(int64_t& x) noexcept; - void reverse(uint16_t& x) noexcept; - void reverse(uint32_t& x) noexcept; - void reverse(uint64_t& x) noexcept; - void reverse(float& x) noexcept; - void reverse(double& x) noexcept; + template <class Value> + void reverse(Value& x) noexcept; // reverse byte order unless native endianness is big template <class ReversibleValue > @@ -155,6 +156,9 @@ namespace endian } // namespace endian } // namespace boost +

The implementation-defined text above is either +big or little according to the endianness of the +platform.

Requirements

The template definitions in this header refer to named requirements whose details are set out in this section. User defined types may @@ -203,9 +207,11 @@ udt_conversion_example.cpp for an example of a UDT that can used in the little_endian, and convert function templates.

Functions

-
int16_t  reverse_value(int16_t x) noexcept;
+
int8_t  reverse_value(int8_t x) noexcept;
+int16_t  reverse_value(int16_t x) noexcept;
 int32_t  reverse_value(int32_t x) noexcept;
 int64_t  reverse_value(int64_t x) noexcept;
+uint8_t  reverse_value(uint8_t x) noexcept;
 uint16_t reverse_value(uint16_t x) noexcept;
 uint32_t reverse_value(uint32_t x) noexcept;
 uint64_t reverse_value(uint64_t x) noexcept;
@@ -215,14 +221,8 @@ double   reverse_value(double x) noexcept;

   
Returns: x, with the order of its 
   constituent bytes reversed.

 
-
void reverse(int16_t& x) noexcept;
-void reverse(int32_t& x) noexcept;
-void reverse(int64_t& x) noexcept;
-void reverse(uint16_t& x) noexcept;
-void reverse(uint32_t& x) noexcept;
-void reverse(uint64_t& x) noexcept;
-void reverse(float& x) noexcept;
-void reverse(double& x) noexcept;

+
template <class Value>
+  void     reverse(Value& x) noexcept;

 

   
Postconditions: The order of the constituent bytes of
   x are reversed.

@@ -333,10 +333,12 @@ provided.

 

 
 
Acknowledgements
Tomas Puverle was instrumental in identifying and articulating the need to 
-support endian conversion as separate from endian integer types. Phil Endecott suggested the form of the value returning signatures. Vicente Botet and other reviewers suggested supporting floating point types and user defined types. General reverse template implementation approach using std::reverse suggested by Mathias Gaunard. Portable implementation approach for 16, 32, and 64-bit integers suggested by tymofey, with avoidance of undefined behavior as suggested by Giovanni Piero Deretta, and a further refinement suggested by Pyry Jahkola. Intrinsic builtins implementation approach for 16, 32, and 64-bit integers suggested by several reviewers, and by David Stone, who provided his Boost licensed macro implementation that became the starting point for boost/endian/detail/intrinsic.hpp.

+support endian conversion as separate from endian integer types. Phil Endecott suggested the form of the value returning signatures. Vicente Botet and other reviewers suggested supporting floating point types and user defined types. General reverse template implementation approach using std::reverse suggested by Mathias Gaunard. Portable implementation approach for 16, 32, and 64-bit integers suggested by tymofey, with avoidance of undefined behavior as suggested by Giovanni Piero Deretta, and a further refinement suggested by Pyry Jahkola. Intrinsic builtins implementation approach for 16, 32, and 64-bit integers suggested by several reviewers, and by David Stone, who provided his Boost licensed macro implementation that became the starting point for boost/endian/detail/intrinsic.hpp. 
+Pierre Talbot provided the int8_t reverse_value() and templated
+reverse() implementations.

 

 
Last revised: 
-29 May, 2013

+12 August, 2014

 
© Copyright Beman Dawes, 2011, 2013

 
Distributed under the Boost Software License, Version 1.0. See www.boost.org/ LICENSE_1_0.txt

 
diff --git a/index.html b/index.html
index 7b7f0b5..6c6f3c4 100644
--- a/index.html
+++ b/index.html
@@ -46,7 +46,7 @@
       Introduction to endianness

       Introduction to the Boost.Endian library

       Choosing approaches

-      Intrinsic built-in support

+      Built-in support for Intrinsics

       Performance

     Timings

     Conclusions

@@ -65,23 +65,15 @@
   
 
 
-
-  
-    
-  
-
Heads up: As development has continues, there have been breaking 
-    changes. Most recently, the endian types were 
-    renamed.

-
 
Abstract

 
 
Boost.Endian provides facilities to manipulate the endianness of integers, 
 floating point, and user defined data.

 
     
     
     
    
-      
  • A need to leverage knowledge of developers who have been using C byte 
+      
  • A need to leverage knowledge of developers who have been using C byte 
       swapping 
-      functions for years.
    
- 
    • 
+      functions for years.
    
       
  • A need to save CPU time when a variable is used many times 
-      relative to its I/O.
    
- 
    • 
-      
  • A need to pass structures to third-party libraries expecting a 
-      specific structure format.
    
- 
    • 
+      relative to its I/O.
+      
  • 
+      
    A need to pass structures to third-party libraries expecting a 
+      specific structure format.
    • 
+      
  • 
+      
    Programmer preference.
    • 
     

     
   
 
 
-
Intrinsic built-in support

-
Recent compilers, including GCC, Clang, and Microsoft, supply intrinsic 
-built-in support for byte swapping. Such support is automatically detected and 
+
Built-in support for Intrinsics

+
Recent compilers, including GCC, Clang, and Microsoft, supply  built-in support for byte swapping 
+intrinsics. Such support is automatically detected and 
 used since it may in smaller and faster generated code, particularly for release 
 builds.

-
Defining BOOST_ENDIAN_NO_INTRINSICS will suppress use 
+
Defining BOOST_ENDIAN_NO_INTRINSICS will suppress use 
 of the intrinsics. Please try defining it if you get compiler errors, such as 
 header byteswap.h not being found.

-
The macro BOOST_ENDIAN_INTRINSIC_MSG is defined as 
+
The macro BOOST_ENDIAN_INTRINSIC_MSG is defined as 
 either "no byte swap intrinsics" or a string describing the 
 particular set of intrinsics being used.

 
@@ -267,9 +260,10 @@ big_endian(x);
   
 
 
-
There will be no performance difference between the two approaches, 
-regardless of the native endianness of the machine. Optimizing compilers will likely 
-generate exactly the same code for both. That conclusion was confirmed by 
+
There will be no performance difference between the two approaches in 
+release builds, 
+regardless of the native endianness of the machine. That's because optimizing compilers will likely 
+generate exactly the same code for each. That conclusion was confirmed by 
 studying the generated assembly code for GCC and Visual C++.

 
 
Now consider a slightly different problem:  

@@ -337,84 +331,180 @@ setup.
 32-bit intrinsics.)

 
 
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
 
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
GNU C++ version 4.7.0
 Iterations: 1000000000, Intrinsics: __builtin_bswap16, etc.
Test CaseEndian
type		Endian
conversion
function
GNU C++ version 4.7.0
 Iterations: 1000000000, Intrinsics: __builtin_bswap16, etc.
Test CaseEndian
type		Endian
conversion
function		
 
16-bit aligned big endian1.37 s0.81 s
16-bit aligned little endian0.83 s0.81 s
16-bit unaligned big endian1.09 s0.83 s
16-bit unaligned little endian1.09 s0.81 s
32-bit aligned big endian0.98 s0.27 s
32-bit aligned little endian0.28 s0.27 s
32-bit unaligned big endian3.82 s0.27 s
32-bit unaligned little endian3.82 s0.27 s
64-bit aligned big endian1.65 s0.41 s
64-bit aligned little endian0.41 s0.41 s
64-bit unaligned big endian17.53 s0.41 s
64-bit unaligned little endian17.52 s0.41 s
16-bit aligned big endian1.37 s0.81 s
16-bit aligned little endian0.83 s0.81 s
16-bit unaligned big endian1.09 s0.83 s
16-bit unaligned little endian1.09 s0.81 s
32-bit aligned big endian0.98 s0.27 s
32-bit aligned little endian0.28 s0.27 s
32-bit unaligned big endian3.82 s0.27 s
32-bit unaligned little endian3.82 s0.27 s
64-bit aligned big endian1.65 s0.41 s
64-bit aligned little endian0.41 s0.41 s
64-bit unaligned big endian17.53 s0.41 s
64-bit unaligned little endian17.52 s0.41 s
 Iterations: 1000000000, Intrinsics: no byte swap intrinsics
Test CaseEndian
type		Endian
conversion
function
 Iterations: 1000000000, Intrinsics: no byte swap intrinsics
Test CaseEndian
type		Endian
conversion
function		
 
16-bit aligned big endian1.95 s0.81 s
16-bit aligned little endian0.83 s0.81 s
16-bit unaligned big endian1.19 s0.81 s
16-bit unaligned little endian1.20 s0.81 s
32-bit aligned big endian0.97 s0.28 s
32-bit aligned little endian0.27 s0.28 s
32-bit unaligned big endian4.10 s0.27 s
32-bit unaligned little endian4.10 s0.27 s
64-bit aligned big endian1.64 s0.42 s
64-bit aligned little endian0.41 s0.41 s
64-bit unaligned big endian17.52 s0.42 s
64-bit unaligned little endian17.52 s0.41 s
16-bit aligned big endian1.95 s0.81 s
16-bit aligned little endian0.83 s0.81 s
16-bit unaligned big endian1.19 s0.81 s
16-bit unaligned little endian1.20 s0.81 s
32-bit aligned big endian0.97 s0.28 s
32-bit aligned little endian0.27 s0.28 s
32-bit unaligned big endian4.10 s0.27 s
32-bit unaligned little endian4.10 s0.27 s
64-bit aligned big endian1.64 s0.42 s
64-bit aligned little endian0.41 s0.41 s
64-bit unaligned big endian17.52 s0.42 s
64-bit unaligned little endian17.52 s0.41 s

 
 

 
 

 
-
-
-
-
-
-
+
Microsoft Visual C++ version 11.0
 Iterations: 1000000000, Intrinsics: cstdlib _byteswap_ushort, etc.
Test CaseEndian
type		Endian
conversion
function

+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
 
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
+
+  
+  
Microsoft Visual C++ version 11.0
 Iterations: 1000000000, Intrinsics: cstdlib _byteswap_ushort, etc.
Test CaseEndian
type		Endian
conversion
function		
 
16-bit aligned big endian0.83 s0.51 s
16-bit aligned little endian0.51 s0.50 s
16-bit unaligned big endian1.37 s0.51 s
16-bit unaligned little endian1.37 s0.50 s
32-bit aligned big endian0.81 s0.50 s
32-bit aligned little endian0.51 s0.51 s
32-bit unaligned big endian2.98 s0.53 s
32-bit unaligned little endian3.00 s0.51 s
64-bit aligned big endian1.33 s0.33 s
64-bit aligned little endian0.34 s0.27 s
64-bit unaligned big endian7.05 s0.33 s
64-bit unaligned little endian7.11 s0.31 s
16-bit aligned big endian0.83 s0.51 s
16-bit aligned little endian0.51 s0.50 s
16-bit unaligned big endian1.37 s0.51 s
16-bit unaligned little endian1.37 s0.50 s
32-bit aligned big endian0.81 s0.50 s
32-bit aligned little endian0.51 s0.51 s
32-bit unaligned big endian2.98 s0.53 s
32-bit unaligned little endian3.00 s0.51 s
64-bit aligned big endian1.33 s0.33 s
64-bit aligned little endian0.34 s0.27 s
64-bit unaligned big endian7.05 s0.33 s
64-bit unaligned little endian7.11 s0.31 s
 Iterations: 1000000000, Intrinsics: no byte swap intrinsics
Test CaseEndian
type		Endian
conversion
function
 Iterations: 1000000000, Intrinsics: no byte swap intrinsics
Test CaseEndian
type		Endian
conversion
function		
 
16-bit aligned big endian0.83 s0.51 s
16-bit aligned little endian0.51 s0.51 s
16-bit unaligned big endian1.36 s0.51 s
16-bit unaligned little endian1.37 s0.51 s
32-bit aligned big endian3.42 s0.50 s
32-bit aligned little endian0.51 s0.51 s
32-bit unaligned big endian2.93 s0.50 s
32-bit unaligned little endian2.95 s0.50 s
64-bit aligned big endian5.99 s0.33 s
64-bit aligned little endian0.33 s0.33 s
64-bit unaligned big endian7.02 s0.27 s
64-bit unaligned little endian7.02 s0.27 s
16-bit aligned big endian0.83 s0.51 s
16-bit aligned little endian0.51 s0.51 s
16-bit unaligned big endian1.36 s0.51 s
16-bit unaligned little endian1.37 s0.51 s
32-bit aligned big endian3.42 s0.50 s
32-bit aligned little endian0.51 s0.51 s
32-bit unaligned big endian2.93 s0.50 s
32-bit unaligned little endian2.95 s0.50 s
64-bit aligned big endian5.99 s0.33 s
64-bit aligned little endian0.33 s0.33 s
64-bit unaligned big endian7.02 s0.27 s
64-bit unaligned little endian7.02 s0.27 s

 
 

 
@@ -487,9 +577,9 @@ paramount.

 
 
Which is better, big-endian or little-endian?

 

-
Big-endian tends to be a 
-bit more of an industry standard, but little-endian may be preferred for 
-applications that run primarily Intel/AMD on x86, x64, and other little-endian 
+
Big-endian tends to be preferred in a networking environment and is a bit 
+more of an industry standard, but little-endian may be preferred for 
+applications that run primarily on x86, x64, and other little-endian 
 CPU's. The Wikipedia article 
 gives more pros and cons.

 

@@ -498,7 +588,7 @@ gives more pros and cons.

 

 
These are the only endian schemes that have any practical value today. PDP-11 
 and the other middle endian approaches are interesting historical curiosities 
-but have no relevance to C++ developers.

+but have no relevance to today's C++ developers.

 

 
 
What are the limitations of floating point support?

@@ -534,16 +624,14 @@ and 16, 32, and 64-bit aligned integers.

   64-bit (double) floating point, as requested.
   
  • Both the endian types and endian conversion functions now support UDTs, as requested.
    • 
   
  • The endian type aliases have been renamed, 
-  using a naming pattern that is consistent for both integer and floating point, 
-  and that emphasizes that aligned types are usually preferred compared to 
-  unaligned types. Unaligned types are deliberately given slightly uglier names.
    • 
+  using a naming pattern that is consistent for both integer and floating point.
   
  • The conversion functions have been much revised, 
   refactored, and otherwise improved based on review comments.
      
     
    • Functions have been renamed to clarify their functionality.
      • 
     
    • Both return-by-value and modify-in-place interfaces are provided, as 
     requested.
      • 
     
    • Synonyms for the BSD byte swapping function names popularized by OS X 
-    and Linux are provided, so that that developers already used to these name 
+    and Linux are provided, so that that developers already used to these names 
     can continue to use them if they wish.
      • 
     
    • In addition to the named-endianness functions, functions that perform 
     compile-time (via template) and run-time (via function argument) dispatch 
@@ -555,34 +643,34 @@ and 16, 32, and 64-bit aligned integers.
      
   
    • For the endian  types, the implementation uses the endian conversion functions, 
   and thus the intrinsics, 
   as requested.
      • 
+  
    • order::native is now a synonym for order::big 
+  or order::little according to the endianness of the platform, as 
+  requested. This reduces the number of template specializations required.
      • 
+  
    • reverse_value() overloads for int8_t and 
+  uint8_t have been added for improved generality. (Pierre Talbot)
      • 
+  
    • Overloads of reverse() have been replaced with a single 
+  reverse() template. (Pierre Talbot)
      • 
   
    • C++11 features such as noexcept are now used, while still 
   supporting C++03 compilers.
      • 
-  
    • Acknowledgements have been updated.
      • 
   
    • Headers have been reorganized to make them easier to read, 
   with a synopsis at the front and implementation following, as requested.
      • 
   
    • Documentation has been revised to address most, but not all, concerns 
   raised during formal review.
      • 
+  
    • Acknowledgements have been updated.
      • 
 
    
 
 
    Acknowledgements
    
-
    Comments and suggestions were 
-received from
-Adder, Benaka Moorthi,
-Christopher Kohlhoff,
-Cliff Green, Daniel James, Gennaro Proto,
-Giovanni Piero Deretta, Gordon Woodhull, dizzy, Hartmut Kaiser, Jeff Flinn,
-John Filo, John Maddock,
-Kim Barrett,
-Marsh Ray,
-Martin Bonner, Mathias Gaunard, Matias Capeletto,
-Neil Mayhew, Paul Bristow, Phil Endecott, Pyry Jahkola, Rene Rivera,
-Robert Stewart, Roland Schwarz, Scott McMurray, 
-Sebastian Redl, 
-Tim Blechmann, Tim Moore, tymofey, Tomas Puverle, Vincente Botet, Yuval Ronen 
-and Vitaly Budovski,.
    
+
    Comments and suggestions were received from Adder, Benaka Moorthi, 
+Christopher Kohlhoff, Cliff Green, Daniel James, Gennaro Proto, Giovanni Piero 
+Deretta, Gordon Woodhull, dizzy, Hartmut Kaiser, Jeff Flinn, John Filo, John 
+Maddock, Kim Barrett, Marsh Ray, Martin Bonner, Mathias Gaunard, Matias 
+Capeletto, Neil Mayhew, Paul Bristow, Pierre Talbot, Phil Endecott, Pyry Jahkola, 
+Rene Rivera, Robert Stewart, Roland Schwarz, Scott McMurray, Sebastian Redl, Tim 
+Blechmann, Tim Moore, tymofey, Tomas Puverle, Vincente Botet, Yuval Ronen and 
+Vitaly Budovski,.
    
 
    
 
    Last revised:
-01 September, 2013
    
+12 August, 2014
    
 
    © Copyright Beman Dawes, 2011, 2013
    
 
    Distributed under the Boost Software License, Version 1.0. See
 www.boost.org/ LICENSE_1_0.txt
    
diff --git a/types.html b/types.html
index 18720a2..3fb31ef 100644
--- a/types.html
+++ b/types.html
@@ -76,7 +76,7 @@
 
 
    Introduction
    
 
    Header boost/endian/types.hpp 
-provides integer and floating point binary types with explicit control over 
+provides integer and floating point binary types with control over 
 byte order, value type, size, and alignment. Typedefs provide easy-to-use names 
 for common configurations.
    
 
    These types provide portable byte-holders for integer data, independent of 
@@ -102,7 +102,7 @@ arithmetic operators are +, +=, -, 
 >>=. Binary relational operators are ==, !=,
 <, <=, >, >=.
    
 
    Automatic implicit conversion to the underlying value type is provided. An 
-explicit conversion constructor from the underlying value type is provided. 
    
+conversion constructor from the underlying value type is provided. 
    
 
    Example
    
 
    The endian_example.cpp program writes a 
 binary file containing four byte big-endian and little-endian integers:
    
@@ -207,6 +207,7 @@ will no longer be relying on unspecified behavior.
    
 
    Two scoped enums are provided:
    
 
    
   
    enum class order {big, little, native};
+
 enum class align {no, yes}; 
    
 
    
 
    One class template is provided:
    
@@ -349,7 +350,13 @@ usual operations on integers are supplied.
    
   {
     //  C++11 features emulated if not available
    
-    enum class order {big, little, native};
+    enum class order
+    {
+      big,                             // big-endian
+      little,                          // little-endian
+      native = implementation-defined  // same as order::big or order::little
+    };
+
     enum class align {no, yes};            
 
     template <order Order, typename T, std::size_t n_bits, align A = align::no>
@@ -361,13 +368,14 @@ usual operations on integers are supplied.
    
       // if BOOST_ENDIAN_FORCE_PODNESS is defined && C++11 POD's are not
       // available then these two constructors will not be present
       endian() noexcept = default;
-      explicit endian(T v) noexcept;
+      endian(T v) noexcept;
 
       endian& operator=(T v) noexcept;
       operator T() const noexcept;
       const char* data() const noexcept;
 
-      // arithmetic operations; additional operators provided by value_type
+      // arithmetic operations
+      //   note that additional operations are provided by the value_type 
       value_type operator+(const endian& x) noexcept;
       endian& operator+=(endian& x, value_type y) noexcept;
       endian& operator-=(endian& x, value_type y) noexcept;
@@ -387,43 +395,44 @@ usual operations on integers are supplied.
    
       endian operator--(endian& x, int) noexcept;
     };
 
-    typedef endian<order::big, float, 32, align::yes>      big_align_float32_t;
-    typedef endian<order::big, double, 64, align::yes>     big_align_float64_t;
+    // aligned big endian floating point types
+    typedef endian<order::big, float, 32, align::yes>       big_align_float32_t;
+    typedef endian<order::big, double, 64, align::yes>      big_align_float64_t;
 
-  // aligned little endian floating point types
-    typedef endian<order::little, float, 32, align::yes>   little_align_float32_t;
-    typedef endian<order::little, double, 64, align::yes>  little_align_float64_t;
+    // aligned little endian floating point types
+    typedef endian<order::little, float, 32, align::yes>    little_align_float32_t;
+    typedef endian<order::little, double, 64, align::yes>   little_align_float64_t;
 
-  // unaligned big endian floating point types
-    typedef endian<order::big, float, 32, align::no>       big_float32un_t;
-    typedef endian<order::big, double, 64, align::no>      big_float64un_t;
+    // unaligned big endian floating point types
+    typedef endian<order::big, float, 32, align::no>        big_float32un_t;
+    typedef endian<order::big, double, 64, align::no>       big_float64un_t;
   
     // unaligned little endian floating point types
-    typedef endian<order::little, float, 32, align::no>    little_float32un_t;
-    typedef endian<order::little, double, 64, align::no>   little_float64un_t;
+    typedef endian<order::little, float, 32, align::no>     little_float32un_t;
+    typedef endian<order::little, double, 64, align::no>    little_float64un_t;
   
     // aligned big endian signed integer types
-    typedef endian<order::big, int16_t, 16, align::yes>    big_align_int16_t;
-  typedef endian<order::big, int32_t, 32, align::yes>      big_align_int32_t;
-  typedef endian<order::big, int64_t, 64, align::yes>      big_align_int64_t;
+    typedef endian<order::big, int16_t, 16, align::yes>     big_align_int16_t;
+    typedef endian<order::big, int32_t, 32, align::yes>     big_align_int32_t;
+    typedef endian<order::big, int64_t, 64, align::yes>     big_align_int64_t;
 
-  // aligned big endian unsigned integer types
-  typedef endian<order::big, uint16_t, 16, align::yes>     big_align_uint16_t;
-  typedef endian<order::big, uint32_t, 32, align::yes>     big_align_uint32_t;
-  typedef endian<order::big, uint64_t, 64, align::yes>     big_align_uint64_t;
+    // aligned big endian unsigned integer types
+    typedef endian<order::big, uint16_t, 16, align::yes>    big_align_uint16_t;
+    typedef endian<order::big, uint32_t, 32, align::yes>    big_align_uint32_t;
+    typedef endian<order::big, uint64_t, 64, align::yes>    big_align_uint64_t;
 
-  // aligned little endian signed integer types
-  typedef endian<order::little, int16_t, 16, align::yes>   little_align_int16_t;
-  typedef endian<order::little, int32_t, 32, align::yes>   little_align_int32_t;
-  typedef endian<order::little, int64_t, 64, align::yes>   little_align_int64_t;
+    // aligned little endian signed integer types
+    typedef endian<order::little, int16_t, 16, align::yes>  little_align_int16_t;
+    typedef endian<order::little, int32_t, 32, align::yes>  little_align_int32_t;
+    typedef endian<order::little, int64_t, 64, align::yes>  little_align_int64_t;
 
-  // aligned little endian unsigned integer types
-  typedef endian<order::little, uint16_t, 16, align::yes>  little_align_uint16_t;
-  typedef endian<order::little, uint32_t, 32, align::yes>  little_align_uint32_t;
-  typedef endian<order::little, uint64_t, 64, align::yes>  little_align_uint64_t;
+    // aligned little endian unsigned integer types
+    typedef endian<order::little, uint16_t, 16, align::yes> little_align_uint16_t;
+    typedef endian<order::little, uint32_t, 32, align::yes> little_align_uint32_t;
+    typedef endian<order::little, uint64_t, 64, align::yes> little_align_uint64_t;
 
-  // aligned native endian typedefs are not provided because
-  // <cstdint> types are superior for this use case
+    // aligned native endian typedefs are not provided because
+    // <cstdint> types are superior for that use case
   
     // unaligned big endian signed integer types
     typedef endian<order::big, int_least8_t, 8>        big_int8_t;
@@ -465,51 +474,56 @@ usual operations on integers are supplied.
    
     typedef endian<order::little, uint_least64_t, 56>  little_uint56_t;
     typedef endian<order::little, uint_least64_t, 64>  little_uint64_t;
   
-    // unaligned native endian signed integer types
-    typedef endian<order::native, int_least8_t, 8>     native_int8_t;
-    typedef endian<order::native, int_least16_t, 16>   native_int16_t;
-    typedef endian<order::native, int_least32_t, 24>   native_int24_t;
-    typedef endian<order::native, int_least32_t, 32>   native_int32_t;
-    typedef endian<order::native, int_least64_t, 40>   native_int40_t;
-    typedef endian<order::native, int_least64_t, 48>   native_int48_t;
-    typedef endian<order::native, int_least64_t, 56>   native_int56_t;
-    typedef endian<order::native, int_least64_t, 64>   native_int64_t;
-  
-    // unaligned native endian unsigned integer types
-    typedef endian<order::native, uint_least8_t, 8>    native_uint8_t;
-    typedef endian<order::native, uint_least16_t, 16>  native_uint16_t;
-    typedef endian<order::native, uint_least32_t, 24>  native_uint24_t;
-    typedef endian<order::native, uint_least32_t, 32>  native_uint32_t;
-    typedef endian<order::native, uint_least64_t, 40>  native_uint40_t;
-    typedef endian<order::native, uint_least64_t, 48>  native_uint48_t;
-    typedef endian<order::native, uint_least64_t, 56>  native_uint56_t;
-    typedef endian<order::native, uint_least64_t, 64>  native_uint64_t;
+  // unaligned native endian signed integer types
+    typedef implementation-defined_int8_t   native_int8_t;
+    typedef implementation-defined_int16_t  native_int16_t;
+    typedef implementation-defined_int24_t  native_int24_t;
+    typedef implementation-defined_int32_t  native_int32_t;
+    typedef implementation-defined_int40_t  native_int40_t;
+    typedef implementation-defined_int48_t  native_int48_t;
+    typedef implementation-defined_int56_t  native_int56_t;
+    typedef implementation-defined_int64_t  native_int64_t;
+
+  // unaligned native endian unsigned integer types
+    typedef implementation-defined_uint8_t   native_uint8_t;
+    typedef implementation-defined_uint16_t  native_uint16_t;
+    typedef implementation-defined_uint24_t  native_uint24_t;
+    typedef implementation-defined_uint32_t  native_uint32_t;
+    typedef implementation-defined_uint40_t  native_uint40_t;
+    typedef implementation-defined_uint48_t  native_uint48_t;
+    typedef implementation-defined_uint56_t  native_uint56_t;
+    typedef implementation-defined_uint64_t  native_uint64_t;
 
   } // namespace endian
 } // namespace boost
    • +

    The implementation-defined text above is either +big or little according to the endianness of the +platform.

    Members

    -

    endian() = default;  // C++03: endian(){}

    +
    + 
    endian() = default;  // C++03: endian(){}
    +

    Effects: Constructs an object of type endian<E, T, n_bits, A>.

    -

    explicit endian(T v);

    +
    endian(T v);

    Effects: Constructs an object of type endian<E, T, n_bits, A>.

    Postcondition: x == v, where x is the constructed object.

    -

    endian& operator=(T v);

    +
    endian& operator=(T v);

    Postcondition: x == v, where x is the constructed object.

    Returns: *this.

    -

    operator T() const;

    +
    operator T() const;

    Returns: The current value stored in *this, converted to value_type.

    -

    const char* data() const;

    +
    const char* data() const;

    Returns: A pointer to the first byte of the endian binary value stored in *this.

    @@ -564,13 +578,10 @@ incrementing a variable in a record. It is very convenient to write:

    representation) regardless of whether a compiler treats char as signed or unsigned.
  • Unaligned types must not cause compilers to insert padding bytes.
    • -
  • The implementation should supply optimizations only in very limited - circumstances. Experience has shown that optimizations of endian +
  • The implementation should supply optimizations with great care. Experience has shown that optimizations of endian integers often become pessimizations when changing machines or compilers. Pessimizations can also happen when changing compiler switches, compiler versions, or CPU models of the same architecture.
    • -
  • It is better software engineering if the same implementation works regardless - of the CPU endianness. In other words, #ifdefs should be avoided in user code.

    • Experience

    Classes with similar functionality have been independently developed by @@ -617,7 +628,7 @@ differs from endian representation size. Vicente Botet and other reviewers suggested supporting floating point types.

    Last revised: -31 August, 2013

    +12 August, 2014

    © Copyright Beman Dawes, 2006-2009, 2013

    Distributed under the Boost Software License, Version 1.0. See www.boost.org/ LICENSE_1_0.txt