AByteBufferView.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Traits/serializable.h>
 
class API_AUI_CORE AByteBufferView {
private:
    const char* mBuffer;
    size_t mSize;
 
public:
    AByteBufferView() noexcept: mBuffer(nullptr), mSize(0) {}
    AByteBufferView(const char* buffer, size_t size) noexcept: mBuffer(buffer), mSize(size) {}
    explicit AByteBufferView(const std::string& string) noexcept: mBuffer(string.data()), mSize(string.size()) {}
    explicit AByteBufferView(std::string_view string) noexcept: mBuffer(string.data()), mSize(string.size()) {}
 
    static AByteBufferView fromRange(const char* begin, const char* end) noexcept {
        return AByteBufferView(begin, std::distance(begin, end));
    }
 
    template <typename T>
    const T& at(size_t byteIndex) const noexcept
    {
        return *reinterpret_cast<const T*>(mBuffer + byteIndex);
    }
 
    [[nodiscard]]
    bool empty() const noexcept {
        return mSize == 0;
    }
 
    [[nodiscard]]
    AByteBufferView slice(std::size_t offset /* to end */) const noexcept {
        return slice(offset, size() - offset);
    }
 
    [[nodiscard]]
    AByteBufferView slice(std::size_t offset, std::size_t size) const noexcept {
        AUI_ASSERTX(offset + size <= mSize, "out of bounds");
        return { mBuffer + offset, size };
    }
 
    [[nodiscard]]
    const char* data() const noexcept {
        return mBuffer;
    }
 
    [[nodiscard]]
    size_t size() const noexcept {
        return mSize;
    }
 
    [[nodiscard]]
    auto begin() const noexcept {
        return data();
    }
    [[nodiscard]]
    auto end() const noexcept {
        return data() + size();
    }
 
    [[nodiscard]]
    AString toHexString() const;
 
    [[nodiscard]]
    AString toBase64String() const;
 
    template<typename T>
    [[nodiscard]]
    const T& as() const {
        if (mSize != sizeof(T)) {
            throw AException("as<T>(): invalid size");
        }
        return *reinterpret_cast<const T*>(mBuffer);
    }
 
    template<typename T>
    [[nodiscard]]
    static AByteBufferView fromRaw(const T& data) noexcept {
        return { reinterpret_cast<const char*>(&data), sizeof(data) };
    }
 
 
    _unique<IInputStream> toStream() const;
};
 
inline std::ostream& operator<<(std::ostream& lhs, const AByteBufferView& rhs) {
    lhs << "[";
    for (const auto b : rhs) {
        char buf[8];
        lhs.write(buf, std::distance(std::begin(buf), fmt::format_to(buf, " {:02x}", b)));
    }
    lhs << " ]";
 
    return lhs;
}
 
template<>
struct ASerializable<AByteBufferView> {
    static void write(IOutputStream& os, AByteBufferView view) {
        os.write(view.data(), view.size());
    }
};