1. mzR
  2. src
  3. boost
  4. endian
  5. buffers.hpp
Browse code

Updating pwiz to 3_0_21263

Steffen Neumann authored on 23/09/2021 12:34:25
Showing1 changed files
src/boost/endian/buffers.hpp
History View file @72fef926d8
1 1 
new file mode 100755
... ... 
@@ -0,0 +1,380 @@
1 
+//  boost/endian/buffers.hpp  ----------------------------------------------------------//
2 
+
3 
+//  (C) Copyright Darin Adler 2000
4 
+//  (C) Copyright Beman Dawes 2006, 2009, 2014
5 
+//  (C) Copyright Peter Dimov 2019
6 
+
7 
+//  Distributed under the Boost Software License, Version 1.0.
8 
+//  See http://www.boost.org/LICENSE_1_0.txt
9 
+
10 
+//  See library home page at http://www.boost.org/libs/endian
11 
+
12 
+//--------------------------------------------------------------------------------------//
13 
+
14 
+//  Original design developed by Darin Adler based on classes developed by Mark
15 
+//  Borgerding. Four original class templates were combined into a single endian
16 
+//  class template by Beman Dawes, who also added the unrolled_byte_loops sign
17 
+//  partial specialization to correctly extend the sign when cover integer size
18 
+//  differs from endian representation size.
19 
+
20 
+// TODO: When a compiler supporting constexpr becomes available, try possible uses.
21 
+
22 
+#ifndef BOOST_ENDIAN_BUFFERS_HPP
23 
+#define BOOST_ENDIAN_BUFFERS_HPP
24 
+
25 
+#if defined(_MSC_VER)
26 
+# pragma warning(push)
27 
+# pragma warning(disable: 4127)  // conditional expression is constant
28 
+#endif
29 
+
30 
+#include <boost/endian/detail/endian_store.hpp>
31 
+#include <boost/endian/detail/endian_load.hpp>
32 
+#include <boost/core/scoped_enum.hpp>
33 
+#include <boost/static_assert.hpp>
34 
+#include <boost/cstdint.hpp>
35 
+#include <boost/config.hpp>
36 
+#include <boost/config/workaround.hpp>
37 
+#include <iosfwd>
38 
+#include <climits>
39 
+#include <cstring>
40 
+
41 
+#if defined(BOOST_BORLANDC) || defined(BOOST_CODEGEARC)
42 
+# pragma pack(push, 1)
43 
+#endif
44 
+
45 
+# if CHAR_BIT != 8
46 
+#   error Platforms with CHAR_BIT != 8 are not supported
47 
+# endif
48 
+
49 
+# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
50 
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
51 
+# else
52 
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
53 
+# endif
54 
+
55 
+// g++ pre-4.6 does not support unrestricted unions, but we have no Config macro for that
56 
+# if (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || BOOST_WORKAROUND(BOOST_GCC, < 40600)) && defined(BOOST_ENDIAN_FORCE_PODNESS)
57 
+#   define BOOST_ENDIAN_NO_CTORS
58 
+# endif
59 
+
60 
+//----------------------------------  synopsis  ----------------------------------------//
61 
+
62 
+namespace boost
63 
+{
64 
+namespace endian
65 
+{
66 
+
67 
+  BOOST_SCOPED_ENUM_START(align)
68 
+  {no, yes
69 
+#   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
70 
+      , unaligned = no, aligned = yes
71 
+#   endif
72 
+  }; BOOST_SCOPED_ENUM_END
73 
+
74 
+  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
75 
+    BOOST_SCOPED_ENUM(align) A = align::no>
76 
+      class endian_buffer;
77 
+
78 
+  // aligned big endian signed integer buffers
79 
+  typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
80 
+  typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
81 
+  typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
82 
+  typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
83 
+
84 
+  // aligned big endian unsigned integer buffers
85 
+  typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
86 
+  typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
87 
+  typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
88 
+  typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
89 
+
90 
+  // aligned little endian signed integer buffers
91 
+  typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
92 
+  typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
93 
+  typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
94 
+  typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
95 
+
96 
+  // aligned little endian unsigned integer buffers
97 
+  typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
98 
+  typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
99 
+  typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
100 
+  typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
101 
+
102 
+  // aligned floating point buffers
103 
+  typedef endian_buffer<order::big, float, 32, align::yes>       big_float32_buf_at;
104 
+  typedef endian_buffer<order::big, double, 64, align::yes>      big_float64_buf_at;
105 
+  typedef endian_buffer<order::little, float, 32, align::yes>    little_float32_buf_at;
106 
+  typedef endian_buffer<order::little, double, 64, align::yes>   little_float64_buf_at;
107 
+
108 
+  // aligned native endian typedefs are not provided because
109 
+  // <cstdint> types are superior for this use case
110 
+
111 
+  // unaligned big endian signed integer buffers
112 
+  typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
113 
+  typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
114 
+  typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
115 
+  typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
116 
+  typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
117 
+  typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
118 
+  typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
119 
+  typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
120 
+
121 
+  // unaligned big endian unsigned integer buffers
122 
+  typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
123 
+  typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
124 
+  typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
125 
+  typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
126 
+  typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
127 
+  typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
128 
+  typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
129 
+  typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
130 
+
131 
+  // unaligned little endian signed integer buffers
132 
+  typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
133 
+  typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
134 
+  typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
135 
+  typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
136 
+  typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
137 
+  typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
138 
+  typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
139 
+  typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
140 
+
141 
+  // unaligned little endian unsigned integer buffers
142 
+  typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
143 
+  typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
144 
+  typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
145 
+  typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
146 
+  typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
147 
+  typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
148 
+  typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
149 
+  typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
150 
+
151 
+  // unaligned native endian signed integer buffers
152 
+  typedef endian_buffer<order::native, int_least8_t, 8>     native_int8_buf_t;
153 
+  typedef endian_buffer<order::native, int_least16_t, 16>   native_int16_buf_t;
154 
+  typedef endian_buffer<order::native, int_least32_t, 24>   native_int24_buf_t;
155 
+  typedef endian_buffer<order::native, int_least32_t, 32>   native_int32_buf_t;
156 
+  typedef endian_buffer<order::native, int_least64_t, 40>   native_int40_buf_t;
157 
+  typedef endian_buffer<order::native, int_least64_t, 48>   native_int48_buf_t;
158 
+  typedef endian_buffer<order::native, int_least64_t, 56>   native_int56_buf_t;
159 
+  typedef endian_buffer<order::native, int_least64_t, 64>   native_int64_buf_t;
160 
+
161 
+  // unaligned native endian unsigned integer buffers
162 
+  typedef endian_buffer<order::native, uint_least8_t, 8>    native_uint8_buf_t;
163 
+  typedef endian_buffer<order::native, uint_least16_t, 16>  native_uint16_buf_t;
164 
+  typedef endian_buffer<order::native, uint_least32_t, 24>  native_uint24_buf_t;
165 
+  typedef endian_buffer<order::native, uint_least32_t, 32>  native_uint32_buf_t;
166 
+  typedef endian_buffer<order::native, uint_least64_t, 40>  native_uint40_buf_t;
167 
+  typedef endian_buffer<order::native, uint_least64_t, 48>  native_uint48_buf_t;
168 
+  typedef endian_buffer<order::native, uint_least64_t, 56>  native_uint56_buf_t;
169 
+  typedef endian_buffer<order::native, uint_least64_t, 64>  native_uint64_buf_t;
170 
+
171 
+  // unaligned floating point buffers
172 
+  typedef endian_buffer<order::big, float, 32, align::no>       big_float32_buf_t;
173 
+  typedef endian_buffer<order::big, double, 64, align::no>      big_float64_buf_t;
174 
+  typedef endian_buffer<order::little, float, 32, align::no>    little_float32_buf_t;
175 
+  typedef endian_buffer<order::little, double, 64, align::no>   little_float64_buf_t;
176 
+  typedef endian_buffer<order::native, float, 32, align::no>    native_float32_buf_t;
177 
+  typedef endian_buffer<order::native, double, 64, align::no>   native_float64_buf_t;
178 
+
179 
+  // Stream inserter
180 
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
181 
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
182 
+  std::basic_ostream<charT, traits>&
183 
+    operator<<(std::basic_ostream<charT, traits>& os,
184 
+      const endian_buffer<Order, T, n_bits, A>& x)
185 
+  {
186 
+    return os << x.value();
187 
+  }
188 
+
189 
+  // Stream extractor
190 
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
191 
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
192 
+  std::basic_istream<charT, traits>&
193 
+    operator>>(std::basic_istream<charT, traits>& is,
194 
+      endian_buffer<Order, T, n_bits, A>& x)
195 
+  {
196 
+    T i;
197 
+    if (is >> i)
198 
+      x = i;
199 
+    return is;
200 
+  }
201 
+
202 
+//----------------------------------  end synopsis  ------------------------------------//
203 
+
204 
+//  endian_buffer class template specializations  --------------------------------------//
205 
+
206 
+//  Specializations that represent unaligned bytes.
207 
+//  Taking an integer type as a parameter provides a nice way to pass both
208 
+//  the size and signedness of the desired integer and get the appropriate
209 
+//  corresponding integer type for the interface.
210 
+
211 
+// Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
212 
+// A: No. The rationale for endian_buffers is to prevent high-cost hidden
213 
+//    conversions. If an implicit conversion operator is supplied, hidden conversions
214 
+//    can occur.
215 
+
216 
+//  unaligned endian_buffer specialization
217 
+
218 
+template< BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits >
219 
+class endian_buffer<Order, T, n_bits, align::no>
220 
+{
221 
+#ifdef BOOST_ENDIAN_NO_CTORS
222 
+public:
223 
+#endif
224 
+
225 
+    BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
226 
+
227 
+    unsigned char value_[ n_bits / 8 ];
228 
+
229 
+public:
230 
+
231 
+    typedef T value_type;
232 
+
233 
+#ifndef BOOST_ENDIAN_NO_CTORS
234 
+
235 
+    endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
236 
+
237 
+    explicit endian_buffer( T val ) BOOST_NOEXCEPT
238 
+    {
239 
+        boost::endian::endian_store<T, n_bits / 8, Order>( value_, val );
240 
+    }
241 
+
242 
+#endif
243 
+
244 
+    endian_buffer& operator=( T val ) BOOST_NOEXCEPT
245 
+    {
246 
+        boost::endian::endian_store<T, n_bits / 8, Order>( value_, val );
247 
+        return *this;
248 
+    }
249 
+
250 
+    value_type value() const BOOST_NOEXCEPT
251 
+    {
252 
+        return boost::endian::endian_load<T, n_bits / 8, Order>( value_ );
253 
+    }
254 
+
255 
+    unsigned char const * data() const BOOST_NOEXCEPT
256 
+    {
257 
+        return value_;
258 
+    }
259 
+
260 
+    unsigned char * data() BOOST_NOEXCEPT
261 
+    {
262 
+        return value_;
263 
+    }
264 
+};
265 
+
266 
+// aligned specializations; only n_bits == 16/32/64 supported
267 
+
268 
+// aligned endian_buffer specialization
269 
+
270 
+template< BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits >
271 
+class endian_buffer<Order, T, n_bits, align::yes>
272 
+{
273 
+private:
274 
+
275 
+    BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
276 
+    BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
277 
+
278 
+    union
279 
+    {
280 
+        unsigned char value_[ n_bits / 8 ];
281 
+        T align_;
282 
+    };
283 
+
284 
+public:
285 
+
286 
+    typedef T value_type;
287 
+
288 
+#ifndef BOOST_ENDIAN_NO_CTORS
289 
+
290 
+    endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
291 
+
292 
+    explicit endian_buffer( T val ) BOOST_NOEXCEPT
293 
+    {
294 
+        boost::endian::endian_store<T, n_bits / 8, Order>( value_, val );
295 
+    }
296 
+
297 
+#endif
298 
+
299 
+    endian_buffer& operator=( T val ) BOOST_NOEXCEPT
300 
+    {
301 
+        boost::endian::endian_store<T, n_bits / 8, Order>( value_, val );
302 
+        return *this;
303 
+    }
304 
+
305 
+    value_type value() const BOOST_NOEXCEPT
306 
+    {
307 
+        return boost::endian::endian_load<T, n_bits / 8, Order>( value_ );
308 
+    }
309 
+
310 
+    unsigned char const * data() const BOOST_NOEXCEPT
311 
+    {
312 
+        return value_;
313 
+    }
314 
+
315 
+    unsigned char * data() BOOST_NOEXCEPT
316 
+    {
317 
+        return value_;
318 
+    }
319 
+};
320 
+
321 
+// aligned native endian_buffer specialization
322 
+
323 
+template< class T, std::size_t n_bits >
324 
+class endian_buffer<order::native, T, n_bits, align::yes>
325 
+{
326 
+private:
327 
+
328 
+    BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
329 
+    BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
330 
+
331 
+    T value_;
332 
+
333 
+public:
334 
+
335 
+    typedef T value_type;
336 
+
337 
+#ifndef BOOST_ENDIAN_NO_CTORS
338 
+
339 
+    endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
340 
+
341 
+    explicit endian_buffer( T val ) BOOST_NOEXCEPT: value_( val )
342 
+    {
343 
+    }
344 
+
345 
+#endif
346 
+
347 
+    endian_buffer& operator=( T val ) BOOST_NOEXCEPT
348 
+    {
349 
+        value_ = val;
350 
+        return *this;
351 
+    }
352 
+
353 
+    value_type value() const BOOST_NOEXCEPT
354 
+    {
355 
+        return value_;
356 
+    }
357 
+
358 
+    unsigned char const * data() const BOOST_NOEXCEPT
359 
+    {
360 
+        return reinterpret_cast< unsigned char const* >( &value_ );
361 
+    }
362 
+
363 
+    unsigned char * data() BOOST_NOEXCEPT
364 
+    {
365 
+        return reinterpret_cast< unsigned char* >( &value_ );
366 
+    }
367 
+};
368 
+
369 
+} // namespace endian
370 
+} // namespace boost
371 
+
372 
+#if defined(BOOST_BORLANDC) || defined(BOOST_CODEGEARC)
373 
+# pragma pack(pop)
374 
+#endif
375 
+
376 
+#if defined(_MSC_VER)
377 
+# pragma warning(pop)
378 
+#endif
379 
+
380 
+#endif // BOOST_ENDIAN_BUFFERS_HPP
Browse code

checkout latest pwiz, ammend Makevars

From: Laurent <lg390@cam.ac.uk>

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@125180 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 15/12/2016 10:21:41
Showing1 changed files
src/boost/endian/buffers.hpp
History View file @94d4ecf589
1 1 
deleted file mode 100644
... ... 
@@ -1,515 +0,0 @@
1 
-//  boost/endian/buffers.hpp  ----------------------------------------------------------//
2 
-
3 
-//  (C) Copyright Darin Adler 2000
4 
-//  (C) Copyright Beman Dawes 2006, 2009, 2014
5 
-
6 
-//  Distributed under the Boost Software License, Version 1.0.
7 
-//  See http://www.boost.org/LICENSE_1_0.txt
8 
-
9 
-//  See library home page at http://www.boost.org/libs/endian
10 
-
11 
-//--------------------------------------------------------------------------------------//
12 
-
13 
-//  Original design developed by Darin Adler based on classes developed by Mark
14 
-//  Borgerding. Four original class templates were combined into a single endian
15 
-//  class template by Beman Dawes, who also added the unrolled_byte_loops sign
16 
-//  partial specialization to correctly extend the sign when cover integer size
17 
-//  differs from endian representation size.
18 
-
19 
-// TODO: When a compiler supporting constexpr becomes available, try possible uses.
20 
-
21 
-#ifndef BOOST_ENDIAN_BUFFERS_HPP
22 
-#define BOOST_ENDIAN_BUFFERS_HPP
23 
-
24 
-#if defined(_MSC_VER)
25 
-# pragma warning(push)
26 
-# pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
27 
-#endif
28 
-
29 
-#ifdef BOOST_ENDIAN_LOG
30 
-# include <iostream>
31 
-#endif
32 
-
33 
-#if defined(__BORLANDC__) || defined( __CODEGEARC__)
34 
-# pragma pack(push, 1)
35 
-#endif
36 
-
37 
-#include <boost/config.hpp>
38 
-#include <boost/predef/detail/endian_compat.h>
39 
-#include <boost/endian/conversion.hpp>
40 
-#include <boost/type_traits/is_signed.hpp>
41 
-#include <boost/cstdint.hpp>
42 
-#include <boost/static_assert.hpp>
43 
-#include <boost/core/scoped_enum.hpp>
44 
-#include <iosfwd>
45 
-#include <climits>
46 
-
47 
-# if CHAR_BIT != 8
48 
-#   error Platforms with CHAR_BIT != 8 are not supported
49 
-# endif
50 
-
51 
-# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
52 
-#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
53 
-# else
54 
-#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
55 
-# endif
56 
-
57 
-# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
58 
-#   define BOOST_ENDIAN_NO_CTORS
59 
-# endif
60 
-
61 
-//----------------------------------  synopsis  ----------------------------------------//
62 
-
63 
-namespace boost
64 
-{
65 
-namespace endian
66 
-{
67 
-
68 
-  BOOST_SCOPED_ENUM_START(align)
69 
-  {no, yes
70 
-#   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
71 
-      , unaligned = no, aligned = yes
72 
-#   endif
73 
-  }; BOOST_SCOPED_ENUM_END
74 
-
75 
-  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
76 
-    BOOST_SCOPED_ENUM(align) A = align::no>
77 
-      class endian_buffer;
78 
-
79 
-  // aligned big endian signed integer buffers
80 
-  typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
81 
-  typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
82 
-  typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
83 
-  typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
84 
-
85 
-  // aligned big endian unsigned integer buffers
86 
-  typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
87 
-  typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
88 
-  typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
89 
-  typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
90 
-
91 
-  // aligned little endian signed integer buffers
92 
-  typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
93 
-  typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
94 
-  typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
95 
-  typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
96 
-
97 
-  // aligned little endian unsigned integer buffers
98 
-  typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
99 
-  typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
100 
-  typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
101 
-  typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
102 
-
103 
-  // aligned native endian typedefs are not provided because
104 
-  // <cstdint> types are superior for this use case
105 
-
106 
-  // unaligned big endian signed integer buffers
107 
-  typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
108 
-  typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
109 
-  typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
110 
-  typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
111 
-  typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
112 
-  typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
113 
-  typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
114 
-  typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
115 
-
116 
-  // unaligned big endian unsigned integer buffers
117 
-  typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
118 
-  typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
119 
-  typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
120 
-  typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
121 
-  typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
122 
-  typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
123 
-  typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
124 
-  typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
125 
-
126 
-  // unaligned little endian signed integer buffers
127 
-  typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
128 
-  typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
129 
-  typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
130 
-  typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
131 
-  typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
132 
-  typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
133 
-  typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
134 
-  typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
135 
-
136 
-  // unaligned little endian unsigned integer buffers
137 
-  typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
138 
-  typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
139 
-  typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
140 
-  typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
141 
-  typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
142 
-  typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
143 
-  typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
144 
-  typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
145 
-
146 
-# ifdef BOOST_BIG_ENDIAN
147 
-  // unaligned native endian signed integer buffers
148 
-  typedef big_int8_buf_t   native_int8_buf_t;
149 
-  typedef big_int16_buf_t  native_int16_buf_t;
150 
-  typedef big_int24_buf_t  native_int24_buf_t;
151 
-  typedef big_int32_buf_t  native_int32_buf_t;
152 
-  typedef big_int40_buf_t  native_int40_buf_t;
153 
-  typedef big_int48_buf_t  native_int48_buf_t;
154 
-  typedef big_int56_buf_t  native_int56_buf_t;
155 
-  typedef big_int64_buf_t  native_int64_buf_t;
156 
-
157 
-  // unaligned native endian unsigned integer buffers
158 
-  typedef big_uint8_buf_t   native_uint8_buf_t;
159 
-  typedef big_uint16_buf_t  native_uint16_buf_t;
160 
-  typedef big_uint24_buf_t  native_uint24_buf_t;
161 
-  typedef big_uint32_buf_t  native_uint32_buf_t;
162 
-  typedef big_uint40_buf_t  native_uint40_buf_t;
163 
-  typedef big_uint48_buf_t  native_uint48_buf_t;
164 
-  typedef big_uint56_buf_t  native_uint56_buf_t;
165 
-  typedef big_uint64_buf_t  native_uint64_buf_t;
166 
-# else
167 
-  // unaligned native endian signed integer buffers
168 
-  typedef little_int8_buf_t   native_int8_buf_t;
169 
-  typedef little_int16_buf_t  native_int16_buf_t;
170 
-  typedef little_int24_buf_t  native_int24_buf_t;
171 
-  typedef little_int32_buf_t  native_int32_buf_t;
172 
-  typedef little_int40_buf_t  native_int40_buf_t;
173 
-  typedef little_int48_buf_t  native_int48_buf_t;
174 
-  typedef little_int56_buf_t  native_int56_buf_t;
175 
-  typedef little_int64_buf_t  native_int64_buf_t;
176 
-
177 
-  // unaligned native endian unsigned integer buffers
178 
-  typedef little_uint8_buf_t   native_uint8_buf_t;
179 
-  typedef little_uint16_buf_t  native_uint16_buf_t;
180 
-  typedef little_uint24_buf_t  native_uint24_buf_t;
181 
-  typedef little_uint32_buf_t  native_uint32_buf_t;
182 
-  typedef little_uint40_buf_t  native_uint40_buf_t;
183 
-  typedef little_uint48_buf_t  native_uint48_buf_t;
184 
-  typedef little_uint56_buf_t  native_uint56_buf_t;
185 
-  typedef little_uint64_buf_t  native_uint64_buf_t;
186 
-# endif
187 
-
188 
-  // Stream inserter
189 
-  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
190 
-    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
191 
-  std::basic_ostream<charT, traits>&
192 
-    operator<<(std::basic_ostream<charT, traits>& os,
193 
-      const endian_buffer<Order, T, n_bits, A>& x)
194 
-  {
195 
-    return os << x.value();
196 
-  }
197 
-
198 
-  // Stream extractor
199 
-  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
200 
-    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
201 
-  std::basic_istream<charT, traits>&
202 
-    operator>>(std::basic_istream<charT, traits>& is,
203 
-      endian_buffer<Order, T, n_bits, A>& x)
204 
-  {
205 
-    T i;
206 
-    if (is >> i)
207 
-      x = i;
208 
-    return is;
209 
-  }
210 
-
211 
-//----------------------------------  end synopsis  ------------------------------------//
212 
-
213 
-  namespace detail
214 
-  {
215 
-
216 
-    // Unrolled loops for loading and storing streams of bytes.
217 
-
218 
-    template <typename T, std::size_t n_bytes,
219 
-      bool sign=boost::is_signed<T>::value >
220 
-    struct unrolled_byte_loops
221 
-    {
222 
-      typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
223 
-
224 
-      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
225 
-        { return static_cast<T>(*(bytes - 1) | (next::load_big(bytes - 1) << 8)); }
226 
-      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
227 
-        { return static_cast<T>(*bytes | (next::load_little(bytes + 1) << 8)); }
228 
-
229 
-      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
230 
-        {
231 
-          *(bytes - 1) = static_cast<char>(value);
232 
-          next::store_big(bytes - 1, static_cast<T>(value >> 8));
233 
-        }
234 
-      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
235 
-        {
236 
-          *bytes = static_cast<char>(value);
237 
-          next::store_little(bytes + 1, static_cast<T>(value >> 8));
238 
-        }
239 
-    };
240 
-
241 
-    template <typename T>
242 
-    struct unrolled_byte_loops<T, 1, false>
243 
-    {
244 
-      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
245 
-        { return *(bytes - 1); }
246 
-      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
247 
-        { return *bytes; }
248 
-      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
249 
-        { *(bytes - 1) = static_cast<char>(value); }
250 
-      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
251 
-        { *bytes = static_cast<char>(value); }
252 
-
253 
-    };
254 
-
255 
-    template <typename T>
256 
-    struct unrolled_byte_loops<T, 1, true>
257 
-    {
258 
-      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
259 
-        { return *reinterpret_cast<const signed char*>(bytes - 1); }
260 
-      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
261 
-        { return *reinterpret_cast<const signed char*>(bytes); }
262 
-      static void store_big(char* bytes, T value)  BOOST_NOEXCEPT
263 
-        { *(bytes - 1) = static_cast<char>(value); }
264 
-      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
265 
-        { *bytes = static_cast<char>(value); }
266 
-    };
267 
-
268 
-    template <typename T, std::size_t n_bytes>
269 
-    inline
270 
-    T load_big_endian(const void* bytes) BOOST_NOEXCEPT
271 
-    {
272 
-      return unrolled_byte_loops<T, n_bytes>::load_big
273 
-        (static_cast<const unsigned char*>(bytes) + n_bytes);
274 
-    }
275 
-
276 
-    template <typename T, std::size_t n_bytes>
277 
-    inline
278 
-    T load_little_endian(const void* bytes) BOOST_NOEXCEPT
279 
-    {
280 
-#   if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
281 
-      // On x86 (which is little endian), unaligned loads are permitted
282 
-      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
283 
-                                 // test and generate code only for the applicable return
284 
-                                 // case since sizeof(T) and n_bytes are known at compile
285 
-                                 // time.
286 
-      {
287 
-        return *reinterpret_cast<T const *>(bytes);
288 
-      }
289 
-#   endif
290 
-      return unrolled_byte_loops<T, n_bytes>::load_little
291 
-        (static_cast<const unsigned char*>(bytes));
292 
-    }
293 
-
294 
-    template <typename T, std::size_t n_bytes>
295 
-    inline
296 
-    void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
297 
-    {
298 
-      unrolled_byte_loops<T, n_bytes>::store_big
299 
-        (static_cast<char*>(bytes) + n_bytes, value);
300 
-    }
301 
-
302 
-    template <typename T, std::size_t n_bytes>
303 
-    inline
304 
-    void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
305 
-    {
306 
-#     if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
307 
-      // On x86 (which is little endian), unaligned stores are permitted
308 
-      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
309 
-                                 // test and generate code only for the applicable return
310 
-                                 // case since sizeof(T) and n_bytes are known at compile
311 
-                                 // time.
312 
-      {
313 
-        *reinterpret_cast<T *>(bytes) = value;
314 
-        return;
315 
-      }
316 
-#     endif
317 
-      unrolled_byte_loops<T, n_bytes>::store_little
318 
-        (static_cast<char*>(bytes), value);
319 
-    }
320 
-
321 
-  } // namespace detail
322 
-
323 
-# ifdef BOOST_ENDIAN_LOG
324 
-    bool endian_log(true);
325 
-# endif
326 
-
327 
-//  endian_buffer class template specializations  --------------------------------------//
328 
-
329 
-    //  Specializations that represent unaligned bytes.
330 
-    //  Taking an integer type as a parameter provides a nice way to pass both
331 
-    //  the size and signedness of the desired integer and get the appropriate
332 
-    //  corresponding integer type for the interface.
333 
-
334 
-    // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
335 
-    // A: No. The rationale for endian_buffers is to prevent high-cost hidden
336 
-    //    conversions. If an implicit conversion operator is supplied, hidden conversions
337 
-    //    can occur.
338 
-
339 
-    //  unaligned big endian_buffer specialization
340 
-    template <typename T, std::size_t n_bits>
341 
-    class endian_buffer< order::big, T, n_bits, align::no >
342 
-    {
343 
-        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
344 
-      public:
345 
-        typedef T value_type;
346 
-#     ifndef BOOST_ENDIAN_NO_CTORS
347 
-        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
348 
-        explicit endian_buffer(T val) BOOST_NOEXCEPT
349 
-        {
350 
-#       ifdef BOOST_ENDIAN_LOG
351 
-          if ( endian_log )
352 
-            std::cout << "big, unaligned, "
353 
-              << n_bits << "-bits, construct(" << val << ")\n";
354 
-#       endif
355 
-          detail::store_big_endian<T, n_bits/8>(m_value, val);
356 
-        }
357 
-#     endif
358 
-        endian_buffer & operator=(T val) BOOST_NOEXCEPT
359 
-        {
360 
-#       ifdef BOOST_ENDIAN_LOG
361 
-          if (endian_log)
362 
-            std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n";
363 
-#       endif
364 
-          detail::store_big_endian<T, n_bits/8>(m_value, val);
365 
-          return *this;
366 
-        }
367 
-        value_type value() const BOOST_NOEXCEPT
368 
-        {
369 
-#       ifdef BOOST_ENDIAN_LOG
370 
-          if ( endian_log )
371 
-            std::cout << "big, unaligned, " << n_bits << "-bits, convert("
372 
-              << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
373 
-#       endif
374 
-          return detail::load_big_endian<T, n_bits/8>(m_value);
375 
-        }
376 
-        const char* data() const BOOST_NOEXCEPT  { return m_value; }
377 
-      protected:
378 
-        char m_value[n_bits/8];
379 
-    };
380 
-
381 
-    //  unaligned little endian_buffer specialization
382 
-    template <typename T, std::size_t n_bits>
383 
-    class endian_buffer< order::little, T, n_bits, align::no >
384 
-    {
385 
-        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
386 
-      public:
387 
-        typedef T value_type;
388 
-#     ifndef BOOST_ENDIAN_NO_CTORS
389 
-        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
390 
-        explicit endian_buffer(T val) BOOST_NOEXCEPT
391 
-        {
392 
-#       ifdef BOOST_ENDIAN_LOG
393 
-          if ( endian_log )
394 
-            std::cout << "little, unaligned, " << n_bits << "-bits, construct("
395 
-              << val << ")\n";
396 
-#       endif
397 
-          detail::store_little_endian<T, n_bits/8>(m_value, val);
398 
-        }
399 
-#     endif
400 
-        endian_buffer & operator=(T val) BOOST_NOEXCEPT
401 
-          { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
402 
-        value_type value() const BOOST_NOEXCEPT
403 
-        {
404 
-#       ifdef BOOST_ENDIAN_LOG
405 
-          if ( endian_log )
406 
-            std::cout << "little, unaligned, " << n_bits << "-bits, convert("
407 
-              << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
408 
-#       endif
409 
-          return detail::load_little_endian<T, n_bits/8>(m_value);
410 
-        }
411 
-        const char* data() const BOOST_NOEXCEPT  { return m_value; }
412 
-      protected:
413 
-        char m_value[n_bits/8];
414 
-    };
415 
-
416 
-  //  align::yes specializations; only n_bits == 16/32/64 supported
417 
-
418 
-    //  aligned big endian_buffer specialization
419 
-    template <typename T, std::size_t n_bits>
420 
-    class endian_buffer<order::big, T, n_bits, align::yes>
421 
-    {
422 
-        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
423 
-        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
424 
-      public:
425 
-        typedef T value_type;
426 
-#     ifndef BOOST_ENDIAN_NO_CTORS
427 
-        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
428 
-        explicit endian_buffer(T val) BOOST_NOEXCEPT
429 
-        {
430 
-#       ifdef BOOST_ENDIAN_LOG
431 
-          if ( endian_log )
432 
-            std::cout << "big, aligned, " << n_bits
433 
-              << "-bits, construct(" << val << ")\n";
434 
-#       endif
435 
-          m_value = ::boost::endian::native_to_big(val);
436 
-        }
437 
-
438 
-#     endif
439 
-        endian_buffer& operator=(T val) BOOST_NOEXCEPT
440 
-        {
441 
-          m_value = ::boost::endian::native_to_big(val);
442 
-          return *this;
443 
-        }
444 
-        //operator value_type() const BOOST_NOEXCEPT
445 
-        //{
446 
-        //  return ::boost::endian::big_to_native(m_value);
447 
-        //}
448 
-        value_type value() const BOOST_NOEXCEPT
449 
-        {
450 
-#       ifdef BOOST_ENDIAN_LOG
451 
-          if ( endian_log )
452 
-            std::cout << "big, aligned, " << n_bits << "-bits, convert("
453 
-              << ::boost::endian::big_to_native(m_value) << ")\n";
454 
-#       endif
455 
-          return ::boost::endian::big_to_native(m_value);
456 
-        }
457 
-        const char* data() const BOOST_NOEXCEPT
458 
-          {return reinterpret_cast<const char*>(&m_value);}
459 
-      protected:
460 
-        T m_value;
461 
-    };
462 
-
463 
-    //  aligned little endian_buffer specialization
464 
-    template <typename T, std::size_t n_bits>
465 
-    class endian_buffer<order::little, T, n_bits, align::yes>
466 
-    {
467 
-        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
468 
-        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
469 
-      public:
470 
-        typedef T value_type;
471 
-#     ifndef BOOST_ENDIAN_NO_CTORS
472 
-        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
473 
-        explicit endian_buffer(T val) BOOST_NOEXCEPT
474 
-        {
475 
-#       ifdef BOOST_ENDIAN_LOG
476 
-          if ( endian_log )
477 
-            std::cout << "little, aligned, " << n_bits
478 
-              << "-bits, construct(" << val << ")\n";
479 
-#       endif
480 
-          m_value = ::boost::endian::native_to_little(val);
481 
-        }
482 
-
483 
-#     endif
484 
-        endian_buffer& operator=(T val) BOOST_NOEXCEPT
485 
-        {
486 
-          m_value = ::boost::endian::native_to_little(val);
487 
-          return *this;
488 
-        }
489 
-        value_type value() const BOOST_NOEXCEPT
490 
-        {
491 
-#       ifdef BOOST_ENDIAN_LOG
492 
-          if ( endian_log )
493 
-            std::cout << "little, aligned, " << n_bits << "-bits, convert("
494 
-              << ::boost::endian::little_to_native(m_value) << ")\n";
495 
-#       endif
496 
-          return ::boost::endian::little_to_native(m_value);
497 
-        }
498 
-        const char* data() const BOOST_NOEXCEPT
499 
-          {return reinterpret_cast<const char*>(&m_value);}
500 
-      protected:
501 
-        T m_value;
502 
-    };
503 
-
504 
-} // namespace endian
505 
-} // namespace boost
506 
-
507 
-#if defined(__BORLANDC__) || defined( __CODEGEARC__)
508 
-# pragma pack(pop)
509 
-#endif
510 
-
511 
-#if defined(_MSC_VER)
512 
-# pragma warning(pop)
513 
-#endif
514 
-
515 
-#endif // BOOST_ENDIAN_BUFFERS_HPP
Browse code

Commit made by the Bioconductor Git-SVN bridge.

Commit id: 0b3d4d9bb71e3ca5891b777610fc8dec103a6d61

Bumped version after KK's updates


Commit id: 9e04409b64757a177893d56c0300904f31945cb1

modified: src/pwiz/data/common/BinaryIndexStream.cpp modified: src/win/i386/libpwiz.a modified: src/win/x64/libpwiz.a


Commit id: f16b04258dc20bf3315beac99708e11728cfc12b

update precompiled lib for windows


Commit id: 5d56197f1148378d92e89b2d0a167e18c4b7ab2e

Bump version, tame .Rbuildignore


Commit id: 432da5bd294c9b87f7761e15bc814c3785c21abf

Merge remote-tracking branch 'origin/boost_159'


Commit id: 92be978bf72d90c2222a19ddf365f6d1acc9f20d

upadte Makevars


Commit id: ae75037a780cead56c4d20bedf822c94fb413677

upgrade to boost 1.5.9



git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@110126 bc3139a8-67e5-0310-9ffc-ced21a209358

s.neumann authored on 01/11/2015 22:33:47
Showing1 changed files
src/boost/endian/buffers.hpp
History View file @ea16439957
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,515 @@
1 
+//  boost/endian/buffers.hpp  ----------------------------------------------------------//
2 
+
3 
+//  (C) Copyright Darin Adler 2000
4 
+//  (C) Copyright Beman Dawes 2006, 2009, 2014
5 
+
6 
+//  Distributed under the Boost Software License, Version 1.0.
7 
+//  See http://www.boost.org/LICENSE_1_0.txt
8 
+
9 
+//  See library home page at http://www.boost.org/libs/endian
10 
+
11 
+//--------------------------------------------------------------------------------------//
12 
+
13 
+//  Original design developed by Darin Adler based on classes developed by Mark
14 
+//  Borgerding. Four original class templates were combined into a single endian
15 
+//  class template by Beman Dawes, who also added the unrolled_byte_loops sign
16 
+//  partial specialization to correctly extend the sign when cover integer size
17 
+//  differs from endian representation size.
18 
+
19 
+// TODO: When a compiler supporting constexpr becomes available, try possible uses.
20 
+
21 
+#ifndef BOOST_ENDIAN_BUFFERS_HPP
22 
+#define BOOST_ENDIAN_BUFFERS_HPP
23 
+
24 
+#if defined(_MSC_VER)
25 
+# pragma warning(push)
26 
+# pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
27 
+#endif
28 
+
29 
+#ifdef BOOST_ENDIAN_LOG
30 
+# include <iostream>
31 
+#endif
32 
+
33 
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
34 
+# pragma pack(push, 1)
35 
+#endif
36 
+
37 
+#include <boost/config.hpp>
38 
+#include <boost/predef/detail/endian_compat.h>
39 
+#include <boost/endian/conversion.hpp>
40 
+#include <boost/type_traits/is_signed.hpp>
41 
+#include <boost/cstdint.hpp>
42 
+#include <boost/static_assert.hpp>
43 
+#include <boost/core/scoped_enum.hpp>
44 
+#include <iosfwd>
45 
+#include <climits>
46 
+
47 
+# if CHAR_BIT != 8
48 
+#   error Platforms with CHAR_BIT != 8 are not supported
49 
+# endif
50 
+
51 
+# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
52 
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
53 
+# else
54 
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
55 
+# endif
56 
+
57 
+# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
58 
+#   define BOOST_ENDIAN_NO_CTORS
59 
+# endif
60 
+
61 
+//----------------------------------  synopsis  ----------------------------------------//
62 
+
63 
+namespace boost
64 
+{
65 
+namespace endian
66 
+{
67 
+
68 
+  BOOST_SCOPED_ENUM_START(align)
69 
+  {no, yes
70 
+#   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
71 
+      , unaligned = no, aligned = yes
72 
+#   endif
73 
+  }; BOOST_SCOPED_ENUM_END
74 
+
75 
+  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
76 
+    BOOST_SCOPED_ENUM(align) A = align::no>
77 
+      class endian_buffer;
78 
+
79 
+  // aligned big endian signed integer buffers
80 
+  typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
81 
+  typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
82 
+  typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
83 
+  typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
84 
+
85 
+  // aligned big endian unsigned integer buffers
86 
+  typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
87 
+  typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
88 
+  typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
89 
+  typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
90 
+
91 
+  // aligned little endian signed integer buffers
92 
+  typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
93 
+  typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
94 
+  typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
95 
+  typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
96 
+
97 
+  // aligned little endian unsigned integer buffers
98 
+  typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
99 
+  typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
100 
+  typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
101 
+  typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
102 
+
103 
+  // aligned native endian typedefs are not provided because
104 
+  // <cstdint> types are superior for this use case
105 
+
106 
+  // unaligned big endian signed integer buffers
107 
+  typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
108 
+  typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
109 
+  typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
110 
+  typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
111 
+  typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
112 
+  typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
113 
+  typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
114 
+  typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
115 
+
116 
+  // unaligned big endian unsigned integer buffers
117 
+  typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
118 
+  typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
119 
+  typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
120 
+  typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
121 
+  typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
122 
+  typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
123 
+  typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
124 
+  typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
125 
+
126 
+  // unaligned little endian signed integer buffers
127 
+  typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
128 
+  typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
129 
+  typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
130 
+  typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
131 
+  typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
132 
+  typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
133 
+  typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
134 
+  typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
135 
+
136 
+  // unaligned little endian unsigned integer buffers
137 
+  typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
138 
+  typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
139 
+  typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
140 
+  typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
141 
+  typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
142 
+  typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
143 
+  typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
144 
+  typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
145 
+
146 
+# ifdef BOOST_BIG_ENDIAN
147 
+  // unaligned native endian signed integer buffers
148 
+  typedef big_int8_buf_t   native_int8_buf_t;
149 
+  typedef big_int16_buf_t  native_int16_buf_t;
150 
+  typedef big_int24_buf_t  native_int24_buf_t;
151 
+  typedef big_int32_buf_t  native_int32_buf_t;
152 
+  typedef big_int40_buf_t  native_int40_buf_t;
153 
+  typedef big_int48_buf_t  native_int48_buf_t;
154 
+  typedef big_int56_buf_t  native_int56_buf_t;
155 
+  typedef big_int64_buf_t  native_int64_buf_t;
156 
+
157 
+  // unaligned native endian unsigned integer buffers
158 
+  typedef big_uint8_buf_t   native_uint8_buf_t;
159 
+  typedef big_uint16_buf_t  native_uint16_buf_t;
160 
+  typedef big_uint24_buf_t  native_uint24_buf_t;
161 
+  typedef big_uint32_buf_t  native_uint32_buf_t;
162 
+  typedef big_uint40_buf_t  native_uint40_buf_t;
163 
+  typedef big_uint48_buf_t  native_uint48_buf_t;
164 
+  typedef big_uint56_buf_t  native_uint56_buf_t;
165 
+  typedef big_uint64_buf_t  native_uint64_buf_t;
166 
+# else
167 
+  // unaligned native endian signed integer buffers
168 
+  typedef little_int8_buf_t   native_int8_buf_t;
169 
+  typedef little_int16_buf_t  native_int16_buf_t;
170 
+  typedef little_int24_buf_t  native_int24_buf_t;
171 
+  typedef little_int32_buf_t  native_int32_buf_t;
172 
+  typedef little_int40_buf_t  native_int40_buf_t;
173 
+  typedef little_int48_buf_t  native_int48_buf_t;
174 
+  typedef little_int56_buf_t  native_int56_buf_t;
175 
+  typedef little_int64_buf_t  native_int64_buf_t;
176 
+
177 
+  // unaligned native endian unsigned integer buffers
178 
+  typedef little_uint8_buf_t   native_uint8_buf_t;
179 
+  typedef little_uint16_buf_t  native_uint16_buf_t;
180 
+  typedef little_uint24_buf_t  native_uint24_buf_t;
181 
+  typedef little_uint32_buf_t  native_uint32_buf_t;
182 
+  typedef little_uint40_buf_t  native_uint40_buf_t;
183 
+  typedef little_uint48_buf_t  native_uint48_buf_t;
184 
+  typedef little_uint56_buf_t  native_uint56_buf_t;
185 
+  typedef little_uint64_buf_t  native_uint64_buf_t;
186 
+# endif
187 
+
188 
+  // Stream inserter
189 
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
190 
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
191 
+  std::basic_ostream<charT, traits>&
192 
+    operator<<(std::basic_ostream<charT, traits>& os,
193 
+      const endian_buffer<Order, T, n_bits, A>& x)
194 
+  {
195 
+    return os << x.value();
196 
+  }
197 
+
198 
+  // Stream extractor
199 
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
200 
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
201 
+  std::basic_istream<charT, traits>&
202 
+    operator>>(std::basic_istream<charT, traits>& is,
203 
+      endian_buffer<Order, T, n_bits, A>& x)
204 
+  {
205 
+    T i;
206 
+    if (is >> i)
207 
+      x = i;
208 
+    return is;
209 
+  }
210 
+
211 
+//----------------------------------  end synopsis  ------------------------------------//
212 
+
213 
+  namespace detail
214 
+  {
215 
+
216 
+    // Unrolled loops for loading and storing streams of bytes.
217 
+
218 
+    template <typename T, std::size_t n_bytes,
219 
+      bool sign=boost::is_signed<T>::value >
220 
+    struct unrolled_byte_loops
221 
+    {
222 
+      typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
223 
+
224 
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
225 
+        { return static_cast<T>(*(bytes - 1) | (next::load_big(bytes - 1) << 8)); }
226 
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
227 
+        { return static_cast<T>(*bytes | (next::load_little(bytes + 1) << 8)); }
228 
+
229 
+      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
230 
+        {
231 
+          *(bytes - 1) = static_cast<char>(value);
232 
+          next::store_big(bytes - 1, static_cast<T>(value >> 8));
233 
+        }
234 
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
235 
+        {
236 
+          *bytes = static_cast<char>(value);
237 
+          next::store_little(bytes + 1, static_cast<T>(value >> 8));
238 
+        }
239 
+    };
240 
+
241 
+    template <typename T>
242 
+    struct unrolled_byte_loops<T, 1, false>
243 
+    {
244 
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
245 
+        { return *(bytes - 1); }
246 
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
247 
+        { return *bytes; }
248 
+      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
249 
+        { *(bytes - 1) = static_cast<char>(value); }
250 
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
251 
+        { *bytes = static_cast<char>(value); }
252 
+
253 
+    };
254 
+
255 
+    template <typename T>
256 
+    struct unrolled_byte_loops<T, 1, true>
257 
+    {
258 
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
259 
+        { return *reinterpret_cast<const signed char*>(bytes - 1); }
260 
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
261 
+        { return *reinterpret_cast<const signed char*>(bytes); }
262 
+      static void store_big(char* bytes, T value)  BOOST_NOEXCEPT
263 
+        { *(bytes - 1) = static_cast<char>(value); }
264 
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
265 
+        { *bytes = static_cast<char>(value); }
266 
+    };
267 
+
268 
+    template <typename T, std::size_t n_bytes>
269 
+    inline
270 
+    T load_big_endian(const void* bytes) BOOST_NOEXCEPT
271 
+    {
272 
+      return unrolled_byte_loops<T, n_bytes>::load_big
273 
+        (static_cast<const unsigned char*>(bytes) + n_bytes);
274 
+    }
275 
+
276 
+    template <typename T, std::size_t n_bytes>
277 
+    inline
278 
+    T load_little_endian(const void* bytes) BOOST_NOEXCEPT
279 
+    {
280 
+#   if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
281 
+      // On x86 (which is little endian), unaligned loads are permitted
282 
+      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
283 
+                                 // test and generate code only for the applicable return
284 
+                                 // case since sizeof(T) and n_bytes are known at compile
285 
+                                 // time.
286 
+      {
287 
+        return *reinterpret_cast<T const *>(bytes);
288 
+      }
289 
+#   endif
290 
+      return unrolled_byte_loops<T, n_bytes>::load_little
291 
+        (static_cast<const unsigned char*>(bytes));
292 
+    }
293 
+
294 
+    template <typename T, std::size_t n_bytes>
295 
+    inline
296 
+    void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
297 
+    {
298 
+      unrolled_byte_loops<T, n_bytes>::store_big
299 
+        (static_cast<char*>(bytes) + n_bytes, value);
300 
+    }
301 
+
302 
+    template <typename T, std::size_t n_bytes>
303 
+    inline
304 
+    void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
305 
+    {
306 
+#     if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
307 
+      // On x86 (which is little endian), unaligned stores are permitted
308 
+      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
309 
+                                 // test and generate code only for the applicable return
310 
+                                 // case since sizeof(T) and n_bytes are known at compile
311 
+                                 // time.
312 
+      {
313 
+        *reinterpret_cast<T *>(bytes) = value;
314 
+        return;
315 
+      }
316 
+#     endif
317 
+      unrolled_byte_loops<T, n_bytes>::store_little
318 
+        (static_cast<char*>(bytes), value);
319 
+    }
320 
+
321 
+  } // namespace detail
322 
+
323 
+# ifdef BOOST_ENDIAN_LOG
324 
+    bool endian_log(true);
325 
+# endif
326 
+
327 
+//  endian_buffer class template specializations  --------------------------------------//
328 
+
329 
+    //  Specializations that represent unaligned bytes.
330 
+    //  Taking an integer type as a parameter provides a nice way to pass both
331 
+    //  the size and signedness of the desired integer and get the appropriate
332 
+    //  corresponding integer type for the interface.
333 
+
334 
+    // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
335 
+    // A: No. The rationale for endian_buffers is to prevent high-cost hidden
336 
+    //    conversions. If an implicit conversion operator is supplied, hidden conversions
337 
+    //    can occur.
338 
+
339 
+    //  unaligned big endian_buffer specialization
340 
+    template <typename T, std::size_t n_bits>
341 
+    class endian_buffer< order::big, T, n_bits, align::no >
342 
+    {
343 
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
344 
+      public:
345 
+        typedef T value_type;
346 
+#     ifndef BOOST_ENDIAN_NO_CTORS
347 
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
348 
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
349 
+        {
350 
+#       ifdef BOOST_ENDIAN_LOG
351 
+          if ( endian_log )
352 
+            std::cout << "big, unaligned, "
353 
+              << n_bits << "-bits, construct(" << val << ")\n";
354 
+#       endif
355 
+          detail::store_big_endian<T, n_bits/8>(m_value, val);
356 
+        }
357 
+#     endif
358 
+        endian_buffer & operator=(T val) BOOST_NOEXCEPT
359 
+        {
360 
+#       ifdef BOOST_ENDIAN_LOG
361 
+          if (endian_log)
362 
+            std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n";
363 
+#       endif
364 
+          detail::store_big_endian<T, n_bits/8>(m_value, val);
365 
+          return *this;
366 
+        }
367 
+        value_type value() const BOOST_NOEXCEPT
368 
+        {
369 
+#       ifdef BOOST_ENDIAN_LOG
370 
+          if ( endian_log )
371 
+            std::cout << "big, unaligned, " << n_bits << "-bits, convert("
372 
+              << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
373 
+#       endif
374 
+          return detail::load_big_endian<T, n_bits/8>(m_value);
375 
+        }
376 
+        const char* data() const BOOST_NOEXCEPT  { return m_value; }
377 
+      protected:
378 
+        char m_value[n_bits/8];
379 
+    };
380 
+
381 
+    //  unaligned little endian_buffer specialization
382 
+    template <typename T, std::size_t n_bits>
383 
+    class endian_buffer< order::little, T, n_bits, align::no >
384 
+    {
385 
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
386 
+      public:
387 
+        typedef T value_type;
388 
+#     ifndef BOOST_ENDIAN_NO_CTORS
389 
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
390 
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
391 
+        {
392 
+#       ifdef BOOST_ENDIAN_LOG
393 
+          if ( endian_log )
394 
+            std::cout << "little, unaligned, " << n_bits << "-bits, construct("
395 
+              << val << ")\n";
396 
+#       endif
397 
+          detail::store_little_endian<T, n_bits/8>(m_value, val);
398 
+        }
399 
+#     endif
400 
+        endian_buffer & operator=(T val) BOOST_NOEXCEPT
401 
+          { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
402 
+        value_type value() const BOOST_NOEXCEPT
403 
+        {
404 
+#       ifdef BOOST_ENDIAN_LOG
405 
+          if ( endian_log )
406 
+            std::cout << "little, unaligned, " << n_bits << "-bits, convert("
407 
+              << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
408 
+#       endif
409 
+          return detail::load_little_endian<T, n_bits/8>(m_value);
410 
+        }
411 
+        const char* data() const BOOST_NOEXCEPT  { return m_value; }
412 
+      protected:
413 
+        char m_value[n_bits/8];
414 
+    };
415 
+
416 
+  //  align::yes specializations; only n_bits == 16/32/64 supported
417 
+
418 
+    //  aligned big endian_buffer specialization
419 
+    template <typename T, std::size_t n_bits>
420 
+    class endian_buffer<order::big, T, n_bits, align::yes>
421 
+    {
422 
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
423 
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
424 
+      public:
425 
+        typedef T value_type;
426 
+#     ifndef BOOST_ENDIAN_NO_CTORS
427 
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
428 
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
429 
+        {
430 
+#       ifdef BOOST_ENDIAN_LOG
431 
+          if ( endian_log )
432 
+            std::cout << "big, aligned, " << n_bits
433 
+              << "-bits, construct(" << val << ")\n";
434 
+#       endif
435 
+          m_value = ::boost::endian::native_to_big(val);
436 
+        }
437 
+
438 
+#     endif
439 
+        endian_buffer& operator=(T val) BOOST_NOEXCEPT
440 
+        {
441 
+          m_value = ::boost::endian::native_to_big(val);
442 
+          return *this;
443 
+        }
444 
+        //operator value_type() const BOOST_NOEXCEPT
445 
+        //{
446 
+        //  return ::boost::endian::big_to_native(m_value);
447 
+        //}
448 
+        value_type value() const BOOST_NOEXCEPT
449 
+        {
450 
+#       ifdef BOOST_ENDIAN_LOG
451 
+          if ( endian_log )
452 
+            std::cout << "big, aligned, " << n_bits << "-bits, convert("
453 
+              << ::boost::endian::big_to_native(m_value) << ")\n";
454 
+#       endif
455 
+          return ::boost::endian::big_to_native(m_value);
456 
+        }
457 
+        const char* data() const BOOST_NOEXCEPT
458 
+          {return reinterpret_cast<const char*>(&m_value);}
459 
+      protected:
460 
+        T m_value;
461 
+    };
462 
+
463 
+    //  aligned little endian_buffer specialization
464 
+    template <typename T, std::size_t n_bits>
465 
+    class endian_buffer<order::little, T, n_bits, align::yes>
466 
+    {
467 
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
468 
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
469 
+      public:
470 
+        typedef T value_type;
471 
+#     ifndef BOOST_ENDIAN_NO_CTORS
472 
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
473 
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
474 
+        {
475 
+#       ifdef BOOST_ENDIAN_LOG
476 
+          if ( endian_log )
477 
+            std::cout << "little, aligned, " << n_bits
478 
+              << "-bits, construct(" << val << ")\n";
479 
+#       endif
480 
+          m_value = ::boost::endian::native_to_little(val);
481 
+        }
482 
+
483 
+#     endif
484 
+        endian_buffer& operator=(T val) BOOST_NOEXCEPT
485 
+        {
486 
+          m_value = ::boost::endian::native_to_little(val);
487 
+          return *this;