bigendianinteger.h

Go to the documentation of this file.

 
#ifndef SEMF_UTILS_PROCESSING_ENDIAN_BIGENDIANINTEGER_H_
#define SEMF_UTILS_PROCESSING_ENDIAN_BIGENDIANINTEGER_H_
 
#include <semf/utils/processing/stdworkarounds/algorithm>
#include <semf/utils/processing/stdworkarounds/bit>
#include <algorithm>
#include <cstdint>
#include <limits>
#include <type_traits>
 
#if __cplusplus >= 201703L
#define IF_CONSTEXPR if constexpr
#else
#define IF_CONSTEXPR if
#endif
 
namespace semf
{
template <typename T>
class BigEndianInteger
{
public:
    constexpr BigEndianInteger(T value);
    virtual ~BigEndianInteger() = default;
 
    static BigEndianInteger<T> max();
    static BigEndianInteger<T> min();
    T native() const;
    bool operator!=(BigEndianInteger<T> other) const;
    BigEndianInteger<T>& operator%=(T i);
    BigEndianInteger<T>& operator&=(T i);
    BigEndianInteger<T>& operator*=(T i);
    BigEndianInteger<T>& operator++();
    BigEndianInteger<T>& operator++(int i);
    BigEndianInteger<T>& operator+=(T i);
    BigEndianInteger<T>& operator--();
    BigEndianInteger<T>& operator--(int i);
    BigEndianInteger<T>& operator-=(T i);
    BigEndianInteger<T>& operator/=(T i);
    BigEndianInteger<T>& operator<<=(T i);
    BigEndianInteger<T>& operator=(T i);
    BigEndianInteger<T>& operator^=(T i);
    bool operator==(BigEndianInteger<T> other) const;
    BigEndianInteger<T>& operator>>=(T i);
    BigEndianInteger<T>& operator|=(T i);
 
private:
    void setValue(T value);
    T m_value;
};
 
template <typename T>
constexpr BigEndianInteger<T>::BigEndianInteger(T value)
: m_value{std::endian::little == std::endian::native ? reverse<T>(reinterpret_cast<uint8_t*>(&value), reinterpret_cast<uint8_t*>(&value) + sizeof(T)) : value}
{
}
 
template <typename T>
BigEndianInteger<T> BigEndianInteger<T>::max()
{
    BigEndianInteger<T> value(std::numeric_limits<T>::max());
    return value;
}
 
template <typename T>
BigEndianInteger<T> BigEndianInteger<T>::min()
{
    BigEndianInteger<T> value(std::numeric_limits<T>::min());
    return value;
}
 
template <typename T>
T BigEndianInteger<T>::native() const
{
    T native = m_value;
    IF_CONSTEXPR(std::endian::little == std::endian::native)
    {
        std::reverse(reinterpret_cast<uint8_t*>(&native), reinterpret_cast<uint8_t*>(&native) + sizeof(T));
    }
    return native;
}
 
template <typename T>
bool BigEndianInteger<T>::operator!=(BigEndianInteger<T> other) const
{
    return m_value != other.m_value;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator%=(T i)
{
    T nativeValue = native();
    nativeValue %= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
void BigEndianInteger<T>::setValue(T value)
{
    m_value = value;
    IF_CONSTEXPR(std::endian::little == std::endian::native)
    {
        std::reverse(reinterpret_cast<uint8_t*>(&m_value), reinterpret_cast<uint8_t*>(&m_value) + sizeof(T));
    }
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator&=(T i)
{
    T nativeValue = native();
    nativeValue &= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator*=(T i)
{
    T nativeValue = native();
    nativeValue *= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator++()
{
    T nativeValue = native();
    nativeValue++;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator++(int i)
{
    (void)i;
    return this->operator++();
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator+=(T i)
{
    T nativeValue = native();
    nativeValue += i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator--()
{
    T nativeValue = native();
    nativeValue--;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator--(int i)
{
    (void)i;
    return this->operator--();
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator-=(T i)
{
    T nativeValue = native();
    nativeValue -= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator/=(T i)
{
    T nativeValue = native();
    nativeValue /= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator<<=(T i)
{
    T nativeValue = native();
    nativeValue <<= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator=(T i)
{
    setValue(i);
    return *this;
}
 
template <typename T>
bool BigEndianInteger<T>::operator==(BigEndianInteger<T> other) const
{
    return m_value == other.m_value;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator>>=(T i)
{
    T nativeValue = native();
    nativeValue >>= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator^=(T i)
{
    T nativeValue = native();
    nativeValue ^= i;
    setValue(nativeValue);
    return *this;
}
 
template <typename T>
BigEndianInteger<T>& BigEndianInteger<T>::operator|=(T i)
{
    T nativeValue = native();
    nativeValue |= i;
    setValue(nativeValue);
    return *this;
}
}  // namespace semf
#endif  // SEMF_UTILS_PROCESSING_ENDIAN_BIGENDIANINTEGER_H_