coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 22:59:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added C++03 implementation

Browse Source
This commit is contained in:
John Wellbelove 2022-02-15 20:58:19 +00:00
parent 11b4f669d3
commit b472563b62
1 changed files with 234 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
include/etl/byte.h
View File

@ -6,127 +6,310 @@
#include "platform.h"
#include "type_traits.h"
#if ETL_CPP11_SUPPORTED
namespace etl
{
#if ETL_CPP11_SUPPORTED && !defined(ETL_BYTE_FORCE_CPP03_IMPLEMENTATION)
enum class byte : unsigned char {};
///************************************************************************
//*************************************************************************
/// To intger.
///************************************************************************
template <typename TInteger>
constexpr
etl::enable_if_t<etl::is_integral<TInteger>::value, TInteger>
to_integer(etl::byte b) noexcept
{
return TInteger(b);
}
///************************************************************************
/// Shift left.
///************************************************************************
//*************************************************************************
template <typename TInteger>
constexpr
etl::enable_if_t<etl::is_integral<TInteger>::value, etl::byte>
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b) noexcept
{
return TInteger(b);
}
//*************************************************************************
/// Shift left.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift) noexcept
{
return etl::byte(static_cast<unsigned int>(b) << shift);
}
///************************************************************************
//*************************************************************************
/// Shift right
///************************************************************************
//*************************************************************************
template <typename TInteger>
constexpr
etl::enable_if_t<etl::is_integral<TInteger>::value, etl::byte>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift) noexcept
{
return etl::byte(static_cast<unsigned int>(b) >> shift);
}
///************************************************************************
//*************************************************************************
/// Shift left equals.
///************************************************************************
//*************************************************************************
template <typename TInteger>
constexpr
etl::enable_if_t<etl::is_integral<TInteger>::value, etl::byte&>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator <<=(etl::byte& b, TInteger shift) noexcept
{
return b = b << shift;;
}
//*************************************************************************
/// Shift right equals.
//*************************************************************************
template <typename TInteger>
constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator >>=(etl::byte& b, TInteger shift) noexcept
{
return b = b >> shift;
}
//*************************************************************************
/// Or.
//*************************************************************************
constexpr etl::byte operator |(etl::byte lhs, etl::byte rhs) noexcept
{
return etl::byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
}
//*************************************************************************
/// And.
//*************************************************************************
constexpr etl::byte operator &(etl::byte lhs, etl::byte rhs) noexcept
{
return etl::byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
}
//*************************************************************************
/// Exclusive Or.
//*************************************************************************
constexpr etl::byte operator ^(etl::byte lhs, etl::byte rhs) noexcept
{
return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
}
//*************************************************************************
/// Or equals.
//*************************************************************************
ETL_CONSTEXPR14 etl::byte& operator |=(etl::byte& lhs, etl::byte rhs) noexcept
{
return lhs = lhs | rhs;
}
//*************************************************************************
/// And equals
//*************************************************************************
ETL_CONSTEXPR14 etl::byte& operator &=(etl::byte& lhs, etl::byte rhs) noexcept
{
return lhs = lhs & rhs;
}
//*************************************************************************
/// Exclusive or equals.
//*************************************************************************
ETL_CONSTEXPR14 etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs) noexcept
{
return lhs = lhs ^ rhs;
}
//*************************************************************************
/// Not.
//*************************************************************************
constexpr etl::byte operator ~(etl::byte b) noexcept
{
return etl::byte(~static_cast<unsigned int>(b));
}
#else
//*************************************************************************
/// The byte class.
//*************************************************************************
class byte
{
public:
// Friend functions
friend etl::byte operator |(etl::byte lhs, etl::byte rhs);
friend etl::byte operator &(etl::byte lhs, etl::byte rhs);
friend etl::byte operator ^(etl::byte lhs, etl::byte rhs);
template <typename TInteger>
friend
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift);
template <typename TInteger>
friend
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift);
template <typename TInteger>
friend
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b);
friend bool operator ==(etl::byte lhs, etl::byte rhs);
// Default constructor
byte()
: value(0U)
{
}
// Construct from a value castable to unsigned char
template <typename T>
explicit byte(T v)
: value(static_cast<unsigned char>(v))
{
}
private:
// Cast to a T
template <typename T>
operator T() const
{
return static_cast<T>(value);
}
// The byte value
unsigned char value;
};
//*************************************************************************
/// Equality test
//*************************************************************************
bool operator ==(etl::byte lhs, etl::byte rhs)
{
return (lhs.value == rhs.value);
}
//*************************************************************************
/// Inequality test
//*************************************************************************
bool operator !=(etl::byte lhs, etl::byte rhs)
{
return !(lhs == rhs);
}
//*************************************************************************
/// To intger.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b)
{
return TInteger(b);
}
//*************************************************************************
/// Shift left.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift)
{
return etl::byte(static_cast<unsigned int>(b) << shift);
}
//*************************************************************************
/// Shift right
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift)
{
return etl::byte(static_cast<unsigned int>(b) >> shift);
}
//*************************************************************************
/// Shift left equals.
//*************************************************************************
template <typename TInteger>
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator <<=(etl::byte& b, TInteger shift)
{
b = b << shift;
return b;
}
///************************************************************************
//*************************************************************************
/// Shift right equals.
///************************************************************************
//*************************************************************************
template <typename TInteger>
constexpr
etl::enable_if_t<etl::is_integral<TInteger>::value, etl::byte&>
operator >>=(etl::byte& b, TInteger shift) noexcept
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator >>=(etl::byte& b, TInteger shift)
{
b = b >> shift;
return b;
}
///************************************************************************
//*************************************************************************
/// Or.
///************************************************************************
constexpr etl::byte operator |(etl::byte lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte operator |(etl::byte lhs, etl::byte rhs)
{
return etl::byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
}
///************************************************************************
//*************************************************************************
/// And.
///************************************************************************
constexpr etl::byte operator &(etl::byte lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte operator &(etl::byte lhs, etl::byte rhs)
{
return etl::byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
}
///************************************************************************
//*************************************************************************
/// Exclusive Or.
///************************************************************************
constexpr etl::byte operator ^(etl::byte lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte operator ^(etl::byte lhs, etl::byte rhs)
{
return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
}
///************************************************************************
//*************************************************************************
/// Or equals.
///************************************************************************
ETL_CONSTEXPR14 etl::byte& operator |=(etl::byte& lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte& operator |=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs | rhs;
}
///************************************************************************
//*************************************************************************
/// And equals
///************************************************************************
ETL_CONSTEXPR14 etl::byte& operator &=(etl::byte& lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte& operator &=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs & rhs;
}
///************************************************************************
//*************************************************************************
/// Exclusive or equals.
///************************************************************************
ETL_CONSTEXPR14 etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs) noexcept
//*************************************************************************
etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs)
{
return lhs = lhs ^ rhs;
}
///************************************************************************
//*************************************************************************
/// Not.
///************************************************************************
constexpr etl::byte operator ~(etl::byte b) noexcept
//*************************************************************************
etl::byte operator ~(etl::byte b)
{
return etl::byte(~static_cast<unsigned int>(b));
return etl::byte(~to_integer<unsigned char>(b));
}
}
#endif
}
#endif