binary.h

Go to the documentation of this file.

/*
 * Copyright 2024 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cstddef>  // IWYU pragma: keep
#include <cstring>
#include <initializer_list>
#include <limits>
#include <ostream>
#include <stdexcept>
#include <string_view>
#include <vector>
 
#include "msgpack_light/details/basic_binary_buffer.h"
 
namespace msgpack_light {
 
namespace details {

[[nodiscard]] inline std::size_t calculate_expanded_memory_buffer_size(
    std::size_t current_size, std::size_t additional_size) {
    std::size_t next_size = current_size;
    while (true) {
        next_size *= 2;
        if (next_size <= current_size) {
            // Overflow
            const std::size_t max_size =
                std::numeric_limits<std::size_t>::max();
            if (max_size - current_size >= additional_size) {
                return max_size;
            }
            throw std::bad_alloc();
        }
        if (next_size - current_size >= additional_size) {
            return next_size;
        }
    }
}

constexpr std::size_t default_binary_capacity = 8U;
 
}  // namespace details
 
class binary;

class binary_view {
public:
    binary_view() noexcept : data_(nullptr), size_(0U) {}

    binary_view(const unsigned char* data, std::size_t size) noexcept
        : data_(data), size_(size) {}

    binary_view(  // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
        const binary& data) noexcept;

    [[nodiscard]] const unsigned char* data() const noexcept { return data_; }

    [[nodiscard]] std::size_t size() const noexcept { return size_; }
 
private:
    const unsigned char* data_;

    std::size_t size_;
};

class binary {
public:
    binary() : buffer_(details::default_binary_capacity), size_(0U) {}

    explicit binary(std::size_t size) : buffer_(size), size_(size) {}

    binary(const unsigned char* data, std::size_t size) : binary(size) {
        if (size == 0U) {
            return;
        }
        std::memcpy(buffer_.data(), data, size);
    }

    explicit binary(binary_view data) : binary(data.data(), data.size()) {}

    explicit binary(const std::vector<unsigned char>& data)
        : binary(data.data(), data.size()) {}

    binary(std::initializer_list<unsigned char> data)
        : binary(data.begin(), data.size()) {}

    explicit binary(std::string_view data_string)
        : binary(data_string.size() / 2U) {
        constexpr std::string_view hex_digits = "0123456789ABCDEF";
        unsigned int byte = 0U;
        bool is_first_digit = true;
        std::size_t current_byte_index = 0U;
        for (char digit : data_string) {
            const auto pos = hex_digits.find(digit);
            if (pos == std::string_view::npos) {
                throw std::invalid_argument("Invalid hex expression.");
            }
            if (is_first_digit) {
                byte = static_cast<unsigned int>(pos);
                is_first_digit = false;
            } else {
                byte <<= 4U;
                byte |= static_cast<unsigned int>(pos);
                buffer_.data()[current_byte_index] =
                    static_cast<unsigned char>(byte);
                ++current_byte_index;
                is_first_digit = true;
            }
        }
        if (!is_first_digit) {
            throw std::invalid_argument("Invalid hex expression.");
        }
    }

    void resize(std::size_t size) {
        if (size > buffer_.size()) {
            buffer_.resize(size);
        }
        size_ = size;
    }

    void reserve(std::size_t size) {
        if (size > buffer_.size()) {
            buffer_.resize(size);
        }
    }

    void append(const unsigned char* data, std::size_t size) {
        const std::size_t current_size = size_;
        const std::size_t remaining_capacity = buffer_.size() - size_;
        if (remaining_capacity < size) {
            reserve(details::calculate_expanded_memory_buffer_size(
                buffer_.size(), size - remaining_capacity));
        }
        std::memcpy(buffer_.data() + current_size, data, size);
        size_ += size;
    }

    binary& operator+=(const binary& other) {
        append(other.data(), other.size());
        return *this;
    }

    [[nodiscard]] unsigned char& operator[](std::size_t index) noexcept {
        return buffer_.data()[index];
    }

    [[nodiscard]] unsigned char operator[](std::size_t index) const noexcept {
        return buffer_.data()[index];
    }

    [[nodiscard]] unsigned char* data() noexcept { return buffer_.data(); }

    [[nodiscard]] const unsigned char* data() const noexcept {
        return buffer_.data();
    }

    [[nodiscard]] std::size_t size() const noexcept { return size_; }

    [[nodiscard]] std::size_t capacity() const noexcept {
        return buffer_.size();
    }

    [[nodiscard]] bool operator==(const binary& other) const noexcept {
        return size_ == other.size_ &&
            std::memcmp(buffer_.data(), other.buffer_.data(), size_) == 0;
    }

    [[nodiscard]] bool operator!=(const binary& other) const noexcept {
        return !operator==(other);
    }
 
private:
    details::basic_binary_buffer buffer_;

    std::size_t size_;
};
 
inline binary_view::binary_view(const binary& data) noexcept
    : data_(data.data()), size_(data.size()) {}

[[nodiscard]] inline binary operator+(const binary& lhs, const binary& rhs) {
    return binary(lhs) += rhs;
}

[[nodiscard]] inline bool operator==(binary_view lhs, binary_view rhs) {
    return lhs.size() == rhs.size() &&
        std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
}

[[nodiscard]] inline bool operator!=(binary_view lhs, binary_view rhs) {
    return !(lhs == rhs);
}

inline std::ostream& operator<<(std::ostream& stream, const binary& value) {
    constexpr std::string_view hex_digits = "0123456789ABCDEF";
    for (std::size_t i = 0; i < value.size(); ++i) {
        const unsigned int byte = value.data()[i];
        // NOLINTNEXTLINE(readability-magic-numbers)
        stream << hex_digits[(byte >> 4U) & 0x0FU];
        // NOLINTNEXTLINE(readability-magic-numbers)
        stream << hex_digits[byte & 0x0FU];
    }
    return stream;
}
 
}  // namespace msgpack_light