endian.h

Go to the documentation of this file.

 
#ifndef SEMF_UTILS_PROCESSING_ENDIAN_ENDIAN_H_
#define SEMF_UTILS_PROCESSING_ENDIAN_ENDIAN_H_
 
#include <semf/utils/processing/endian/bigendianinteger.h>
#include <semf/utils/processing/endian/littleendianinteger.h>
#include <semf/utils/processing/stdworkarounds/bit>
#include <algorithm>
#include <cstdint>
 
namespace semf
{
using int16be = BigEndianInteger<int16_t>;
using int16le = LittleEndianInteger<int16_t>;
using int32be = BigEndianInteger<int32_t>;
using int32le = LittleEndianInteger<int32_t>;
using int64be = BigEndianInteger<int64_t>;
using int64le = LittleEndianInteger<int64_t>;
using uint16be = BigEndianInteger<uint16_t>;
using uint16le = LittleEndianInteger<uint16_t>;
using uint32be = BigEndianInteger<uint32_t>;
using uint32le = LittleEndianInteger<uint32_t>;
using uint64be = BigEndianInteger<uint64_t>;
using uint64le = LittleEndianInteger<uint64_t>;
class Endian
{
public:
    virtual ~Endian() = default;
 
    template <typename T>
    static void fromBigEndian(const void* data, size_t size, void* buffer);
    template <typename T>
    static T fromBigEndian(const void* data);
    template <typename T>
    static T fromBigEndian(T data);
    template <typename T>
    static void fromLittleEndian(const void* data, size_t size, void* buffer);
    template <typename T>
    static T fromLittleEndian(const void* data);
    template <typename T>
    static T fromLittleEndian(T data);
    template <typename T>
    static void toBigEndian(const void* data, size_t size, void* buffer);
    template <typename T>
    static void toBigEndian(T data, void* buffer);
    template <typename T>
    static T toBigEndian(T data);
    template <typename T>
    static void toLittleEndian(const void* data, size_t size, void* buffer);
    template <typename T>
    static void toLittleEndian(T data, void* buffer);
    template <typename T>
    static T toLittleEndian(T data);
 
private:
    Endian() = default;
};
 
template <typename T>
void Endian::fromBigEndian(const void* data, size_t size, void* buffer)
{
    const T* typedData = reinterpret_cast<const T*>(data);
    T* typedBuffer = reinterpret_cast<T*>(buffer);
 
    if (std::endian::big == std::endian::native)
    {
        std::copy(typedData, typedData + size, typedBuffer);
    }
    else
    {
        std::for_each(typedData, typedData + size,
                      [&](T value)
                      {
                          std::reverse_copy(reinterpret_cast<uint8_t*>(&value), reinterpret_cast<uint8_t*>(&value) + sizeof(T),
                                            reinterpret_cast<uint8_t*>(typedBuffer));
                          typedBuffer++;
                      });
    }
}
 
template <typename T>
T Endian::fromBigEndian(const void* data)
{
    T value;
    Endian::fromBigEndian<T>(data, 1, &value);
    return value;
}
 
template <typename T>
T Endian::fromBigEndian(T data)
{
    return Endian::fromBigEndian<T>(&data);
}
 
template <typename T>
void Endian::fromLittleEndian(const void* data, size_t size, void* buffer)
{
    const T* typedData = reinterpret_cast<const T*>(data);
    T* typedBuffer = reinterpret_cast<T*>(buffer);
 
    if (std::endian::little == std::endian::native)
    {
        std::copy(typedData, typedData + size, typedBuffer);
    }
    else
    {
        std::for_each(typedData, typedData + size,
                      [&](T value)
                      {
                          std::reverse_copy(reinterpret_cast<uint8_t*>(&value), reinterpret_cast<uint8_t*>(&value) + sizeof(T),
                                            reinterpret_cast<uint8_t*>(typedBuffer));
                          typedBuffer++;
                      });
    }
}
 
template <typename T>
T Endian::fromLittleEndian(const void* data)
{
    T value;
    Endian::fromLittleEndian<T>(data, 1, &value);
    return value;
}
 
template <typename T>
T Endian::fromLittleEndian(T data)
{
    return Endian::fromLittleEndian<T>(&data);
}
 
template <typename T>
void Endian::toBigEndian(const void* data, size_t size, void* buffer)
{
    Endian::fromBigEndian<T>(data, size, buffer);
}
 
template <typename T>
void Endian::toBigEndian(T data, void* buffer)
{
    Endian::toBigEndian<T>(&data, 1, buffer);
}
 
template <typename T>
T Endian::toBigEndian(T data)
{
    T value;
    Endian::toBigEndian<T>(data, &value);
    return value;
}
 
template <typename T>
void Endian::toLittleEndian(const void* data, size_t size, void* buffer)
{
    Endian::fromLittleEndian<T>(data, size, buffer);
}
 
template <typename T>
void Endian::toLittleEndian(T data, void* buffer)
{
    Endian::toLittleEndian<T>(&data, 1, buffer);
}
 
template <typename T>
T Endian::toLittleEndian(T data)
{
    T value;
    Endian::toLittleEndian<T>(data, &value);
    return value;
}
}  // namespace semf
#endif  // SEMF_UTILS_PROCESSING_ENDIAN_ENDIAN_H_