ByteConverter.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#ifndef ARP_USE_ARP_SYSTEM_CORE
#include "Arp/Base/Core/ByteConverter.hpp"
#else
#include "Arp/System/Core/Arp.h"
#include <algorithm>
namespace Arp
{
 
class ByteConverter
{
private: // construction/destruction
    ByteConverter(void) = delete;
    ByteConverter(const ByteConverter& arg) = delete;
    ByteConverter& operator=(const ByteConverter& arg) = delete;
    ~ByteConverter(void) = delete;
 
public: // static operations
    template<class T>
    static void Swap(T& value);
 
    static void Swap(byte* pBuffer, size_t size);
 
 
    static void Swap(int8& value);
 
    static void Swap(byte& value);
 
    static void Swap(int16& value);
 
    static void Swap(uint16& value);
 
    template<class T>
    static void ReverseCopy(const T& source, T& target);
 
    static void ReverseCopy(const byte* pSource, byte* pTarget, size_t size);
};
 
// inline methods of class ByteConverter
template<class T>
inline void ByteConverter::Swap(T& value)
{
    Swap((byte*)&value, sizeof(T));
}
 
inline void ByteConverter::Swap(byte* pBuffer, size_t size)
{
    std::reverse(pBuffer, pBuffer + size);
}
 
inline void ByteConverter::Swap(byte& /*value*/)
{
    // overloaded for optimization: nothing to do
}
 
inline void ByteConverter::Swap(int8& /*value*/)
{
    // overload for optimization: nothing to do
}
 
// optimization to avoid call of algorithm for types with sizeof(T) <= 2
inline void ByteConverter::Swap(int16& value)
{
    std::swap(*reinterpret_cast<byte*>(&value), *(reinterpret_cast<byte*>(&value) + 1));
}
 
// optimization to avoid call of algorithm for types with sizeof(T) <= 2
inline void ByteConverter::Swap(uint16& value)
{
    std::swap(*reinterpret_cast<byte*>(&value), *(reinterpret_cast<byte*>(&value) + 1));
}
 
inline void ByteConverter::ReverseCopy(const byte* pSource, byte* pTarget, size_t size)
{
    std::reverse_copy(pSource, pSource + size, pTarget);
}
 
template<class T>
inline void ByteConverter::ReverseCopy(const T& source, T& target)
{
    const byte* pSource = reinterpret_cast<const byte*>(&source);
    byte* pTarget = reinterpret_cast<byte*>(&target);
    std::reverse_copy(pSource, pSource + sizeof(T), pTarget);
}
 
} // end of namespace Arp
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE