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

Simplify endian_arithmetic

Browse Source
This commit is contained in:
Peter Dimov
2019-04-27 22:46:32 +03:00
parent 43d21860a4
commit 9efbcd7c7b
1 changed files with 39 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
include/boost/endian/arithmetic.hpp
View File

@ -2,6 +2,7 @@
// (C) Copyright Darin Adler 2000
// (C) Copyright Beman Dawes 2006, 2009, 2014
// (C) Copyright Peter Dimov 2019
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
@ -26,25 +27,23 @@
# pragma warning(disable:4365) // conversion ... signed/unsigned mismatch
#endif
#if defined(__BORLANDC__) || defined( __CODEGEARC__)
# pragma pack(push, 1)
#endif
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <boost/predef/other/endian.h>
#include <boost/endian/conversion.hpp>
#include <boost/endian/buffers.hpp>
#define BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
#include <boost/endian/detail/cover_operators.hpp>
#undef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
#include <boost/type_traits/is_signed.hpp>
#include <boost/cstdint.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/scoped_enum.hpp>
#include <boost/predef/other/endian.h>
#include <boost/static_assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <iosfwd>
#include <climits>
#if defined(__BORLANDC__) || defined( __CODEGEARC__)
# pragma pack(push, 1)
#endif
# if CHAR_BIT != 8
# error Platforms with CHAR_BIT != 8 are not supported
# endif
@ -74,7 +73,7 @@ namespace endian
{
template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
BOOST_SCOPED_ENUM(align) A = align::no>
BOOST_SCOPED_ENUM(align) Align = align::no>
class endian_arithmetic;
// big endian signed integer aligned types
@ -279,107 +278,41 @@ namespace endian
//---------------------------------- end synopsis ------------------------------------//
// endian class template specializations ---------------------------------------------//
template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
BOOST_SCOPED_ENUM(align) Align>
class endian_arithmetic:
public endian_buffer<Order, T, n_bits, Align>,
private cover_operators<endian_arithmetic<Order, T, n_bits, Align>, T>
{
private:
// Specializations that represent unaligned bytes.
// Taking an integer type as a parameter provides a nice way to pass both
// the size and signness of the desired integer and get the appropriate
// corresponding integer type for the interface.
typedef endian_buffer<Order, T, n_bits, Align> inherited;
// unaligned integer big endian specialization
template <typename T, std::size_t n_bits>
class endian_arithmetic< order::big, T, n_bits, align::no >
: public endian_buffer< order::big, T, n_bits, align::no >,
cover_operators<endian_arithmetic<order::big, T, n_bits>, T>
public:
typedef T value_type;
#ifndef BOOST_ENDIAN_NO_CTORS
endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic( T val ) BOOST_NOEXCEPT: inherited( val )
{
BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
typedef endian_buffer< order::big, T, n_bits, align::no > inherited;
public:
typedef T value_type;
# ifndef BOOST_ENDIAN_NO_CTORS
endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT: inherited( val )
{
}
# endif
endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
{ inherited::operator=( val ); return *this; }
operator value_type() const BOOST_NOEXCEPT { return this->value(); }
};
}
// unaligned little endian specialization
template <typename T, std::size_t n_bits>
class endian_arithmetic< order::little, T, n_bits, align::no >
: public endian_buffer< order::little, T, n_bits, align::no >,
cover_operators< endian_arithmetic< order::little, T, n_bits >, T >
#endif
endian_arithmetic& operator=( T val ) BOOST_NOEXCEPT
{
BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
typedef endian_buffer< order::little, T, n_bits, align::no > inherited;
public:
typedef T value_type;
# ifndef BOOST_ENDIAN_NO_CTORS
endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT: inherited( val )
{
}
# endif
endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
{ inherited::operator=( val ); return *this; }
operator value_type() const BOOST_NOEXCEPT { return this->value(); }
};
inherited::operator=( val );
return *this;
}
// align::yes specializations; only n_bits == 16/32/64 supported
// aligned big endian specialization
template <typename T, std::size_t n_bits>
class endian_arithmetic<order::big, T, n_bits, align::yes>
: public endian_buffer< order::big, T, n_bits, align::yes >,
cover_operators<endian_arithmetic<order::big, T, n_bits, align::yes>, T>
operator value_type() const BOOST_NOEXCEPT
{
BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
typedef endian_buffer< order::big, T, n_bits, align::yes > inherited;
public:
typedef T value_type;
# ifndef BOOST_ENDIAN_NO_CTORS
endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT: inherited( val )
{
}
# endif
endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
{
inherited::operator=( val );
return *this;
}
operator value_type() const BOOST_NOEXCEPT { return this->value(); }
};
// aligned little endian specialization
template <typename T, std::size_t n_bits>
class endian_arithmetic<order::little, T, n_bits, align::yes>
: public endian_buffer< order::little, T, n_bits, align::yes >,
cover_operators<endian_arithmetic<order::little, T, n_bits, align::yes>, T>
{
BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
typedef endian_buffer< order::little, T, n_bits, align::yes > inherited;
public:
typedef T value_type;
# ifndef BOOST_ENDIAN_NO_CTORS
endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT: inherited( val )
{
}
# endif
endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
{
inherited::operator=( val );
return *this;
}
operator value_type() const BOOST_NOEXCEPT { return this->value(); }
};
return this->value();
}
};
} // namespace endian
} // namespace boost