Bytes.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2021 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * Bytes.hpp
 *
 * Helper functions for byte operations.
 *
 *  Created on: Feb 3, 2021
 *      Author: ans
 */

#ifndef HELPER_BYTES_HPP_
#define HELPER_BYTES_HPP_

#include <algorithm>    // std::copy, std::reverse
#include <array>        // std::array
#include <cctype>       // std::isprint
#include <cstddef>      // std::size_t
#include <cstdint>      // std::[u]int[8,16,32,54]_t
#include <stdexcept>    // std::invalid_argument
#include <string>       // std::to_string
#include <vector>       // std::vector

namespace crawlservpp::Helper::Bytes {

    // for convenience
    using Bytes = std::vector<std::uint8_t>;

    /*
     * CONSTANTS
     */


    constexpr auto first{0};

    constexpr auto second{1};

    constexpr auto third{2};

    constexpr auto fourth{3};

    constexpr auto fifth{4};

    constexpr auto sixth{5};

    constexpr auto seventh{6};

    constexpr auto eighth{7};

    constexpr auto oneByteBits{8};

    constexpr auto twoBytesBits{16};

    constexpr auto threeBytesBits{24};

    constexpr auto fourBytesBits{32};

    constexpr auto fiveBytesBits{40};

    constexpr auto sixBytesBits{48};

    constexpr auto sevenBytesBits{56};

    constexpr auto sizeEight{8};

    constexpr auto sizeFour{4};

    constexpr auto sizeTwo{2};


    /*
     * DECLARATION
     */


    bool isBigEndian() noexcept;
    bool isFloatBigEndian() noexcept;


    std::uint64_t bytesToUInt64(const Bytes& bytes, std::size_t& pos);
    std::uint64_t bytesToUInt64(const Bytes& bytes, std::size_t& pos, std::size_t len);
    std::int64_t bytesToInt64(const Bytes& bytes, std::size_t& pos);
    std::int64_t bytesToInt64(const Bytes& bytes, std::size_t& pos, std::size_t len);
    std::uint32_t bytesToUInt32(const Bytes& bytes, std::size_t& pos);
    std::int32_t bytesToInt32(const Bytes& bytes, std::size_t& pos);
    std::uint16_t bytesToUInt16(const Bytes& bytes, std::size_t& pos);
    std::int16_t bytesToInt16(const Bytes& bytes, std::size_t& pos);
    double bytesToDouble(const Bytes& bytes, std::size_t& pos);


    std::array<std::uint8_t, sizeEight> uInt64ToBytes(std::uint64_t number);
    std::array<std::uint8_t, sizeEight> int64ToBytes(std::int64_t number);
    std::array<std::uint8_t, sizeFour> uInt32ToBytes(std::uint32_t number);
    std::array<std::uint8_t, sizeFour> int32ToBytes(std::int32_t number);
    std::array<std::uint8_t, sizeTwo> uInt16ToBytes(std::uint16_t number);
    std::array<std::uint8_t, sizeTwo> int16ToBytes(std::int16_t number);
    std::array<std::uint8_t, sizeEight> doubleToBytes(double number);


    std::string byteToHexString(std::uint8_t byte);
    std::string charToString(char c);


    /*
     * IMPLEMENTATION
     */

    /*
     * ENDIANNESS
     */


    inline bool isBigEndian() noexcept {
        const std::uint8_t one{1};

        return *(reinterpret_cast<const char *>(&one)) != 1;
    }


    inline bool isFloatBigEndian() noexcept {
        const auto minusOne{-1.F};

        return *(reinterpret_cast<const std::uint8_t *>(&minusOne)) > 0;
    }

    /*
     * BYTES-TO-NUMBER CONVERSION
     */


    inline std::uint64_t bytesToUInt64(const Bytes& bytes, std::size_t& pos) {
        std::array<std::uint8_t, sizeEight> numberBytes{
            bytes[pos + first], bytes[pos + second], bytes[pos + third], bytes[pos + fourth],
            bytes[pos + fifth], bytes[pos + sixth], bytes[pos + seventh], bytes[pos + eighth]
        };

        pos += sizeEight;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(numberBytes.begin(), numberBytes.end());
        }

        return static_cast<std::uint64_t>(numberBytes[eighth]) << sevenBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[seventh]) << sixBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[sixth]) << fiveBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[fifth]) << fourBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[fourth]) << threeBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[third]) << twoBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[second]) << oneByteBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[first]);
    }


    inline std::uint64_t bytesToUInt64(const Bytes& bytes, std::size_t& pos, std::size_t len) {
        if(len > sizeEight) {
            throw std::invalid_argument(
                    "Bytes::bytesToUInt64():"
                    " Only numbers up to a length of eight bytes are supported (len="
                    + std::to_string(len)
                    + ")"
            );
        }

        std::array<std::uint8_t, sizeEight> numberBytes{};

        for(std::size_t n{}; n < len; ++n) {
            numberBytes.at(n) = bytes[pos + n];
        };

        pos += len;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(numberBytes.begin(), numberBytes.end());
        }

        return static_cast<std::uint64_t>(numberBytes[eighth]) << sevenBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[seventh]) << sixBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[sixth]) << fiveBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[fifth]) << fourBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[fourth]) << threeBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[third]) << twoBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[second]) << oneByteBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint64_t>(numberBytes[first]);
    }


    inline std::int64_t bytesToInt64(const Bytes& bytes, std::size_t& pos, std::size_t len) {
        const std::uint64_t withoutSign{bytesToUInt64(bytes, pos, len)};

        return *reinterpret_cast<const std::int64_t *>(&withoutSign);
    }


    inline std::int64_t bytesToInt64(const Bytes& bytes, std::size_t& pos) {
        const std::uint64_t withoutSign{bytesToUInt64(bytes, pos)};

        return *reinterpret_cast<const std::int64_t *>(&withoutSign);
    }


    inline std::uint32_t bytesToUInt32(const Bytes& bytes, std::size_t& pos) {
        std::array<std::uint8_t, sizeFour> numberBytes{
            bytes[pos + first], bytes[pos + second], bytes[pos + third], bytes[pos + fourth]
        };

        pos += sizeFour;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(numberBytes.begin(), numberBytes.end());
        }

        return static_cast<std::uint32_t>(numberBytes[fourth]) << threeBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint32_t>(numberBytes[third]) << twoBytesBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint32_t>(numberBytes[second]) << oneByteBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint32_t>(numberBytes[first]);
    }


    inline std::int32_t bytesToInt32(const Bytes& bytes, std::size_t& pos) {
        const std::uint32_t withoutSign{bytesToUInt32(bytes, pos)};

        return *reinterpret_cast<const std::int32_t *>(&withoutSign);
    }


    inline std::uint16_t bytesToUInt16(const Bytes& bytes, std::size_t& pos) {
        std::array<std::uint8_t, sizeTwo> numberBytes{
            bytes[pos + first], bytes[pos + second]
        };

        pos += sizeTwo;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(numberBytes.begin(), numberBytes.end());
        }

        return static_cast<std::uint16_t>(numberBytes[second]) << oneByteBits //NOLINT(hicpp-signed-bitwise)
                | static_cast<std::uint16_t>(numberBytes[first]);
    }


    inline std::int16_t bytesToInt16(const Bytes& bytes, std::size_t& pos) {
        const std::uint16_t withoutSign{bytesToUInt16(bytes, pos)};

        return *reinterpret_cast<const std::int16_t *>(&withoutSign);
    }


    inline double bytesToDouble(const Bytes& bytes, std::size_t& pos) {
        std::array<std::uint8_t, sizeEight> numberBytes{
            bytes[pos + eighth], bytes[pos + seventh], bytes[pos + sixth], bytes[pos + fifth],
            bytes[pos + fourth], bytes[pos + third], bytes[pos + second], bytes[pos + first]
        };

        pos += sizeEight;

        if(Helper::Bytes::isFloatBigEndian()) {
            std::reverse(numberBytes.begin(), numberBytes.end());
        }

        return reinterpret_cast<const double&>(*(numberBytes.data()));
    }

    /*
     * NUMBER-TO-BYTES CONVERSION
     */


    inline std::array<std::uint8_t, sizeEight> uInt64ToBytes(std::uint64_t number) {
        std::array<std::uint8_t, sizeEight> result{};

        reinterpret_cast<std::uint64_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeEight> int64ToBytes(std::int64_t number) {
        std::array<std::uint8_t, sizeEight> result{};

        reinterpret_cast<std::int64_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeFour> uInt32ToBytes(std::uint32_t number) {
        std::array<std::uint8_t, sizeFour> result{};

        reinterpret_cast<std::uint32_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeFour> int32ToBytes(std::int32_t number) {
        std::array<std::uint8_t, sizeFour> result{};

        reinterpret_cast<std::int32_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeTwo> uInt16ToBytes(std::uint16_t number) {
        std::array<std::uint8_t, sizeTwo> result{};

        reinterpret_cast<std::uint16_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeTwo> int16ToBytes(std::int16_t number) {
        std::array<std::uint8_t, sizeTwo> result{};

        reinterpret_cast<std::int16_t&>(*result.data()) = number;

        if(Helper::Bytes::isBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }


    inline std::array<std::uint8_t, sizeEight> doubleToBytes(double number) {
        std::array<std::uint8_t, sizeEight> result{};

        reinterpret_cast<double&>(*result.data()) = number;

        if(!Helper::Bytes::isFloatBigEndian()) {
            std::reverse(result.begin(), result.end());
        }

        return result;
    }

    /*
     * STRING REPRESENTATION
     */


    inline std::string byteToHexString(std::uint8_t byte) {
        constexpr std::array hexChars{
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
        };

        constexpr auto resultSize{4};
        constexpr auto hex240{0xF0};
        constexpr auto hex15{0xF};
        constexpr auto hexShift{4};

        std::string result{"0x"};

        result.reserve(resultSize);

        result.push_back(hexChars.at(((byte & hex240) >> hexShift)));   //NOLINT(hicpp-signed-bitwise)
        result.push_back(hexChars.at(byte & hex15));                    //NOLINT(hicpp-signed-bitwise)

        return result;
    }


    inline std::string charToString(char c) {
        switch(c) {
        case '\0':
            return "\\0";

        case '\a':
            return "\\a";

        case '\f':
            return "\\f";

        case '\n':
            return "\\n";

        case '\r':
            return "\\r";

        case '\v':
            return "\\v";

        case '\t':
            return "\\t";

        default:
            if(std::isprint(c) != 0) {
                return std::string(c, 1);
            }

            break;
        }

        return byteToHexString(static_cast<std::uint8_t>(c));
    }

} /* namespace crawlservpp::Helper::Bytes */

#endif /* HELPER_BYTES_HPP_ */