byte_array.h

#ifndef OE_UTIL_BYTE_ARRAY_H
#define OE_UTIL_BYTE_ARRAY_H
 
#include "../common.h"
 
#include <cstdint>
#include <vector>
#include <algorithm>
#include <string>
#include <cstddef>
#include <span>
 
namespace oe
{
    typedef std::vector<std::byte> ByteArray;
    typedef std::span<const std::byte> ByteSpan;
};
 
namespace oe::util
{
    inline ByteArray convertUint8VectorToByteArray(const std::vector<uint8_t>& input)
    {
        ByteArray result(input.size());
 
        std::ranges::transform(input, result.begin(),
            [] (const uint8_t& c) { return std::byte(c); }
        );
 
        return result;
    }
 
    inline std::vector<uint8_t> convertByteArrayToUint8Vector(ByteSpan input)
    {
        std::vector<uint8_t> result(input.size());
 
        std::ranges::transform(input, result.begin(),
            [] (const std::byte& c) { return std::to_integer<char>(c); }
        );
 
        return result;
    }
 
    template <typename T>
    inline T convertFromByteArray(ByteSpan input)
    {
        return *reinterpret_cast<const T*>(input.data());
    }
 
    template <typename T>
    inline ByteArray convertToByteArray(const T& input)
    {
        ByteArray result;
 
        constexpr const size_t size = sizeof(T);
 
        result.reserve(size);
 
        auto ptr = reinterpret_cast<const uint8_t*>(&input);
        for (std::size_t i=0; i<size; ++i)
        {
            result.push_back(std::byte(ptr[i]));
        }
 
        return result;
    }
 
    inline std::string bytesToStr(ByteSpan input)
    {
        if (input.size() == 0)
        {
            return "";
        }
 
        return {reinterpret_cast<const char*>(input.data()), input.size()};
    }
 
    inline ByteArray strToBytes(std::string_view input)
    {
        ByteArray result(input.size());
 
        std::ranges::transform(input, result.begin(),
            [] (char c) { return std::byte(c); }
        );
 
        return result;
    }
 
    std::string bytesToHex(ByteSpan input, bool uppercase = false);
 
    ByteArray hexToBytes(const std::string& input);
};
 
#endif