AByteBuffer.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/Util/Assert.h"
#include "SharedPtr.h"
 
#include <cstddef>
#include <cstring>
#include <string>
#include <stdexcept>
#include <cassert>
#include "AUI/Core.h"
#include <AUI/Traits/serializable.h>
#include "AByteBufferView.h"
 
 
class API_AUI_CORE AByteBuffer final: public IOutputStream {
private:
    char* mBuffer = nullptr;
    size_t mCapacity = 0;
    size_t mSize = 0;
 
public:
    using iterator = char*;
 
    AByteBuffer();
    AByteBuffer(const char* buffer, size_t size);
    explicit AByteBuffer(size_t initialCapacity);
    AByteBuffer(const unsigned char* buffer, size_t size);
    AByteBuffer(AByteBufferView other) {
        reserve(other.size());
        memcpy(mBuffer, other.data(), other.size());
        mSize = other.size();
    }
 
    AByteBuffer(const AByteBuffer& other): AByteBuffer(AByteBufferView(other)) {}
    AByteBuffer(AByteBuffer&& other) noexcept;
 
    ~AByteBuffer();
 
    void write(const char* src, size_t size) override;
 
 
    [[nodiscard]]
    AByteBufferView slice(std::size_t offset, std::size_t size) const noexcept {
        return operator AByteBufferView().slice(offset, size);
    }
 
    [[nodiscard]]
    AByteBufferView slice(std::size_t offset /* to end */) const noexcept {
        return operator AByteBufferView().slice(offset);
    }
 
    void write(IInputStream& stream, size_t size);
 
    operator AByteBufferView() const noexcept {
        return { mBuffer, mSize };
    }
 
    void clear() {
        delete[] mBuffer;
        mBuffer = nullptr;
        mSize = mCapacity = 0;
    }
 
    void reserve(size_t size);
 
    void increaseInternalBuffer(size_t size) {
        reserve(mCapacity + size);
    }
 
    void grow(size_t size) {
        auto availableToWrite = getAvailableToWrite();
        if (availableToWrite < size) {
            increaseInternalBuffer((glm::max)(getReserved() * 2, size_t(size - availableToWrite)));
        }
    }
 
    size_t getAvailableToWrite() const {
        return getReserved() - getSize();
    }
 
 
    char* data() const
    {
        return mBuffer;
    }
 
    template <typename T>
    T& at(size_t byteIndex)
    {
        return *reinterpret_cast<T*>(mBuffer + byteIndex);
    }
 
 
    template <typename T>
    const T& at(size_t byteIndex) const
    {
        return *reinterpret_cast<T*>(mBuffer + byteIndex);
    }
 
    void setSize(size_t s) {
        AUI_ASSERTX(s <= mCapacity, "size cannot be greater than reserved buffer size; did you mean AByteBuffer::resize?");
        mSize = s;
    }
    void increaseSize(size_t s) {
        mSize += s;
        AUI_ASSERTX(mSize <= mCapacity, "size cannot be greater than reserved buffer size; did you mean AByteBuffer::resize?");
    }
 
    void resize(size_t s) {
        if (mCapacity < s) {
            reserve(s);
        }
        mSize = s;
    }
 
    void reallocate(size_t s) {
        if (mCapacity != s) {
            delete[] mBuffer;
            if (s == 0) {
                mBuffer = nullptr;
            } else {
                mBuffer = new char[s];
            }
            mCapacity = s;
        }
        mSize = s;
    }
 
    size_t getSize() const noexcept {
        return mSize;
    }
 
    bool empty() const noexcept {
        return mSize == 0;
    }
 
    size_t size() const noexcept {
        return mSize;
    }
 
    size_t capacity() const noexcept {
        return mCapacity;
    }
 
    size_t getReserved() const noexcept {
        return mCapacity;
    }
 
    AByteBuffer& operator=(AByteBuffer&& other) noexcept {
        if (&other == this) {
            return *this;
        }
 
        delete[] mBuffer;
        mBuffer = other.mBuffer;
        mCapacity = other.mCapacity;
        mSize = other.mSize;
 
        other.mBuffer = nullptr;
        other.mCapacity = 0;
        other.mSize = 0;
 
        return *this;
    }
    AByteBuffer& operator=(const AByteBuffer& other) {
        if (&other == this) {
            return *this;
        }
 
        if (mCapacity < other.size()) {
            reallocate(other.size());
        }
        std::memcpy(mBuffer, other.data(), other.size());
        mSize = other.mSize;
 
        return *this;
    }
 
    bool operator==(const AByteBuffer& r) const;
    bool operator!=(const AByteBuffer& r) const;
 
    char* begin()
    {
        return mBuffer;
    }
    char* end()
    {
        return mBuffer + mSize;
    }
    char* endReserved()
    {
        return mBuffer + mCapacity;
    }
    const char* begin() const
    {
        return mBuffer;
    }
    const char* end() const
    {
        return mBuffer + mSize;
    }
 
 
    template<typename T>
    T as() const {
        return AByteBufferView(*this).template as<T>();
    }
 
    [[nodiscard]]
    AString toHexString() const {
        return AByteBufferView(*this).toHexString();
    }
 
    [[nodiscard]]
    AString toBase64String() const {
        return AByteBufferView(*this).toBase64String();
    }
 
    iterator erase(iterator begin, iterator end) noexcept {
        AUI_ASSERT(ownsIterator(begin));
        AUI_ASSERT(ownsIterator(end));
        std::memmove(begin, end, std::distance(end, AByteBuffer::end()));
        setSize(size() - std::distance(begin, end));
        return begin;
    }
 
    [[nodiscard]]
    bool ownsIterator(iterator i) const noexcept {
        return i >= begin() && i <= end();
    }
 
    static AByteBuffer fromStream(aui::no_escape<IInputStream> is);
    static AByteBuffer fromStream(aui::no_escape<IInputStream> is, size_t sizeRestriction);
 
    static AByteBuffer fromString(const AString& string);
    static AByteBuffer fromHexString(const AString& string);
    static AByteBuffer fromBase64String(const AString& encodedString);
};
 
API_AUI_CORE std::ostream& operator<<(std::ostream& o, AByteBufferView buffer);
 
template<>
struct ASerializable<AByteBuffer> {
    static void write(IOutputStream& os, const AByteBuffer& value) {
        os.write(value.data(), value.size());
    }
};