littleendianinteger.h

Go to the documentation of this file.

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