AByteBuffer.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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());
   }
};

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.