Buffer.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Hash.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include <algorithm>
#include <cstddef>
#include <cstring>
#include <initializer_list>
#include <string>
#include <tuple>
#include <vector>
 
namespace CeresEngine {
 
    class Buffer {
    public:
        using Iterator = Byte*;
 
        using ConstIterator = const Byte*;
 
    private:
        Byte* mBuffer = nullptr;
 
        size_t mSize = 0;
 
        size_t mCapacity = 0;
 
        bool mOwns = true;
 
    public:
        Buffer() noexcept;
 
        Buffer(std::nullptr_t) noexcept; // NOLINT
 
        explicit Buffer(size_t size) noexcept;
 
        explicit Buffer(Byte* buffer, size_t size, bool copy = false) noexcept;
 
        explicit Buffer(const Byte* buffer, size_t size) noexcept;
 
        Buffer(std::initializer_list<unsigned char> bytes) noexcept;
 
    public:
        Buffer(const Buffer& other) noexcept = delete;
 
        Buffer& operator=(const Buffer& other) noexcept = delete;
 
        Buffer(Buffer&& other) noexcept;
 
        Buffer& operator=(Buffer&& other) noexcept;
 
        ~Buffer() noexcept;
 
    public:
        [[nodiscard]] Buffer copy() const noexcept;
 
    public:
        Byte* data() noexcept { return mBuffer; }
 
        [[nodiscard]] const Byte* data() const noexcept { return mBuffer; }
 
        Byte* buffer() noexcept { return mBuffer; }
 
        [[nodiscard]] const Byte* buffer() const noexcept { return mBuffer; }
 
        [[nodiscard]] size_t size() const noexcept { return mSize; }
 
        [[nodiscard]] size_t capacity() const noexcept { return mCapacity; }
 
        [[nodiscard]] bool empty() const noexcept { return mSize == 0; }
 
        [[nodiscard]] bool owns() const noexcept { return mOwns; }
 
        [[nodiscard]] bool valid() const noexcept { return mBuffer != nullptr; }
 
    public:
        [[nodiscard]] Iterator begin() noexcept { return mBuffer; }
 
        [[nodiscard]] Iterator end() noexcept { return mBuffer + mSize; }
 
        [[nodiscard]] ConstIterator begin() const noexcept { return mBuffer; }
 
        [[nodiscard]] ConstIterator end() const noexcept { return mBuffer + mSize; }
 
        [[nodiscard]] ConstIterator cbegin() const noexcept { return mBuffer; }
 
        [[nodiscard]] ConstIterator cend() const noexcept { return mBuffer + mSize; }
 
    public:
        bool operator==(const Buffer& other) const noexcept;
 
        bool operator!=(const Buffer& other) const noexcept;
 
        Byte& operator[](size_t offset) noexcept;
 
        Byte operator[](size_t offset) const noexcept;
 
        explicit operator bool() const noexcept;
 
        operator const unsigned char*() const noexcept; // NOLINT
        operator const char*() const noexcept; // NOLINT
        operator unsigned char*() noexcept; // NOLINT
        operator char*() noexcept; // NOLINT
 
        //        operator std::vector<UInt8>() const noexcept { //
        //        NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
        //            return std::vector<UInt8>(begin(), end());
        //        }
 
    public:
        void resize(size_t newSize) noexcept;
 
        void reserve(size_t newCapacity) noexcept;
 
        void own() noexcept;
 
        void append(const Buffer& buffer) noexcept;
 
        void write(const char* buf, size_t length) noexcept;
 
        [[nodiscard]] auto reference(size_t start = 0, size_t length = std::numeric_limits<size_t>::max()) const noexcept -> Buffer;
 
        [[nodiscard]] std::string hexdump() const noexcept;
 
        [[nodiscard]] std::string hexstring() const noexcept;
 
        friend std::ostream& operator<<(std::ostream& os, const Buffer& buffer);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    inline bool Buffer::operator==(const Buffer& other) const noexcept {
        if(mBuffer == other.mBuffer && mSize == other.mSize) {
            return true;
        }
        if(mSize != other.mSize) {
            return false;
        }
 
        return memcmp(mBuffer, other.mBuffer, mSize) == 0;
    }
 
    inline bool Buffer::operator!=(const Buffer& other) const noexcept { return !(*this == other); }
    inline Byte& Buffer::operator[](const size_t offset) noexcept { return mBuffer[offset]; }
    inline Byte Buffer::operator[](const size_t offset) const noexcept { return mBuffer[offset]; }
 
    inline Buffer::operator bool() const noexcept { return valid(); }
 
    inline Buffer::operator const unsigned char*() const noexcept { return reinterpret_cast<const unsigned char*>(data()); }
    inline Buffer::operator const char*() const noexcept { return reinterpret_cast<const char*>(data()); }
    inline Buffer::operator unsigned char*() noexcept { return reinterpret_cast<unsigned char*>(data()); }
    inline Buffer::operator char*() noexcept { return reinterpret_cast<char*>(data()); }
 
    // ---------------------------------------------------------------------------------------------
 
    class CopyableBuffer : public Buffer {
    public:
        using Buffer::Buffer;
 
        CopyableBuffer() noexcept;
 
        CopyableBuffer(const CopyableBuffer& other) noexcept;
        CopyableBuffer& operator=(const CopyableBuffer& other) noexcept;
 
        CopyableBuffer(CopyableBuffer&& other) noexcept;
        CopyableBuffer& operator=(CopyableBuffer&& other) noexcept;
 
        CopyableBuffer(const Buffer& other) noexcept; // NOLINT
        CopyableBuffer(Buffer&& other) noexcept; // NOLINT
    };
 
} // namespace CeresEngine
 
namespace CeresEngine {
    using ByteBuffer = Buffer;
}
 
template<> struct std::hash<CeresEngine::Buffer> {
    size_t operator()(const CeresEngine::Buffer& buffer) {
        using CeresEngine::hash;
        return hash(buffer.begin(), buffer.end());
    }
};
 
template<> struct std::hash<CeresEngine::CopyableBuffer> : std::hash<CeresEngine::Buffer> {};