MemoryView.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 "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <iterator>
 
#if defined(CE_MEMORY_VIEW_NO_DEBUG_BOUNDS_CHECK)
#define CE_MEMORY_VIEW_BOUNDS_CHECK(i)
#else
#include <cassert>
#define CE_MEMORY_VIEW_BOUNDS_CHECK(i) CE_ASSERT((i) < this->size())
#endif
 
namespace CeresEngine {
 
    template<typename T> class MemoryView {
    public:
        using value_type = T;
        using size_type = size_t;
        using difference_type = ptrdiff_t;
        using reference = T&;
        using const_reference = const T&;
        using pointer = T*;
        using const_pointer = const T*;
        using iterator = T*;
        using const_iterator = const T*;
        using reverse_iterator = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
        using ValueType = value_type;
        using SizeType = size_type;
        using DifferenceType = difference_type;
        using Reference = reference;
        using ConstReference = const_reference;
        using Pointer = pointer;
        using ConstPointer = const_pointer;
        using Iterator = iterator;
        using ConstIterator = const_iterator;
        using ReverseIterator = reverse_iterator;
        using ConstReverseIterator = const_reverse_iterator;
 
        static constexpr bool isMutable = !std::is_const_v<T>;
 
    private:
        T* mPointer = nullptr;
 
        SizeType mSize = 0;
 
    public:
        MemoryView() = default;
 
        MemoryView(std::nullptr_t) {}
 
        MemoryView(T* ptr, const SizeType size) : mPointer(ptr), mSize(size) {}
 
        template<typename U> explicit MemoryView(const MemoryView<U>& view) : MemoryView(view.template as<T>()) {}
 
        template<typename Container> MemoryView(Container& container, SizeType offset = 0) : MemoryView(container.data() + offset, container.size() - offset) {}
 
        MemoryView(const MemoryView&) = default;
        MemoryView(MemoryView&&) = default;
 
        MemoryView& operator=(const MemoryView&) = default;
        MemoryView& operator=(MemoryView&&) = default;
 
        void reset(Pointer ptr = nullptr, const SizeType size = 0) {
            mPointer = ptr;
            mSize = size;
        }
 
        void reset(const SizeType size) { mSize = size; }
 
        [[nodiscard]] MemoryView<T> slice(SizeType offset, SizeType length = ~0ul) const noexcept {
            offset = std::clamp(offset, size_t(0), mSize);
            length = std::clamp(length, size_t(0), mSize - offset);
 
//            if(offset > mSize) {
//                offset = mSize;
//                length = 0;
//            } else if((offset + length) > mSize || length == ~0ul) {
//                length = mSize - offset;
//            }
 
            CE_ASSERT(mSize >= (offset + length));
            return MemoryView<T>(mPointer + offset, length);
        }
 
        explicit operator bool() const { return mPointer != nullptr; }
 
        [[nodiscard]] Pointer get() noexcept requires(isMutable)
        {
            return mPointer;
        }
 
        [[nodiscard]] ConstPointer get() const noexcept { return mPointer; }
 
        [[nodiscard]] Reference at(SizeType index) requires(isMutable)
        {
            CE_MEMORY_VIEW_BOUNDS_CHECK(index);
            return *(mPointer + index);
        }
 
        [[nodiscard]] ConstReference at(SizeType index) const {
            CE_MEMORY_VIEW_BOUNDS_CHECK(index);
            return *(mPointer + index);
        }
 
        // Gets the element at the given `index` in the memory view.
        [[nodiscard]] ConstReference operator[](SizeType index) const { return *(mPointer + index); }
 
        [[nodiscard]] Reference operator[](SizeType index) requires(isMutable)
        {
            return *(mPointer + index);
        }
 
        [[nodiscard]] ConstReference front() const { return at(0); }
 
        [[nodiscard]] Reference front() requires(isMutable)
        {
            return at(0);
        }
 
        [[nodiscard]] ConstReference back() const { return at(mSize - 1); }
 
        [[nodiscard]] Reference back() requires(isMutable)
        {
            return at(mSize - 1);
        }
 
        [[nodiscard]] ConstPointer data() const noexcept requires(!isMutable)
        {
            return mPointer;
        }
 
        [[nodiscard]] Pointer data() const noexcept requires(isMutable)
        {
            return mPointer;
        }
 
    public: // Iterators
        [[nodiscard]] Iterator begin() noexcept requires(isMutable)
        {
            return data();
        }
 
        [[nodiscard]] ConstIterator begin() const noexcept { return data(); }
 
        [[nodiscard]] ConstIterator cbegin() const noexcept { return data(); }
 
        [[nodiscard]] Iterator end() noexcept requires(isMutable)
        {
            return data() + mSize;
        }
 
        [[nodiscard]] ConstIterator end() const noexcept { return data() + mSize; }
 
        [[nodiscard]] ConstIterator cend() const noexcept { return data() + mSize; }
 
        [[nodiscard]] ReverseIterator rbegin() noexcept requires(isMutable)
        {
            return ReverseIterator(end());
        }
 
        [[nodiscard]] ConstReverseIterator rbegin() const noexcept { return ConstReverseIterator(end()); }
 
        [[nodiscard]] ConstReverseIterator crbegin() const noexcept { return ConstReverseIterator(end()); }
 
        [[nodiscard]] ReverseIterator rend() noexcept requires(isMutable)
        {
            return ReverseIterator(begin());
        }
 
        [[nodiscard]] ConstReverseIterator rend() const noexcept { return ConstReverseIterator(begin()); }
 
        [[nodiscard]] ConstReverseIterator crend() const noexcept { return ConstReverseIterator(begin()); }
 
    public: // Capacity
        [[nodiscard]] bool empty() const noexcept { return mSize == 0; }
 
        [[nodiscard]] SizeType size() const noexcept { return mSize; }
 
        template<typename U> [[nodiscard]] MemoryView<U> as() const noexcept {
            return MemoryView<U>(reinterpret_cast<U*>(mPointer), mSize * sizeof(T) / sizeof(U));
        }
 
    public:
        [[nodiscard]] String hexdump() const;
        void hexdump(std::ostream& stream) const;
 
        [[nodiscard]] String toHex() const;
        void toHex(std::ostream& stream) const;
    };
 
    namespace internal {
        [[nodiscard]] String memoryViewHexdump(const MemoryView<Byte>& memoryView);
        void memoryViewHexdump(const MemoryView<Byte>& memoryView, std::ostream& stream);
 
        [[nodiscard]] String memoryViewToHex(const MemoryView<Byte>& memoryView);
        void memoryViewToHex(const MemoryView<Byte>& memoryView, std::ostream& stream);
    } // namespace internal
 
    template<typename T> String MemoryView<T>::hexdump() const {
        if constexpr(std::is_same_v<T, Byte>) {
            return internal::memoryViewHexdump(*this);
        } else {
            return internal::memoryViewHexdump(as<Byte>());
        }
    }
 
    template<typename T> void MemoryView<T>::hexdump(std::ostream& stream) const {
        if constexpr(std::is_same_v<T, Byte>) {
            internal::memoryViewHexdump(*this, stream);
        } else {
            internal::memoryViewHexdump(as<Byte>(), stream);
        }
    }
 
    template<typename T> String MemoryView<T>::toHex() const {
        if constexpr(std::is_same_v<T, Byte>) {
            return internal::memoryViewToHex(*this);
        } else {
            return internal::memoryViewToHex(as<Byte>());
        }
    }
 
    template<typename T> void MemoryView<T>::toHex(std::ostream& stream) const {
        if constexpr(std::is_same_v<T, Byte>) {
            internal::memoryViewToHex(*this, stream);
        } else {
            internal::memoryViewToHex(as<Byte>(), stream);
        }
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> MemoryView<T> make_memory_view(T* ptr, size_t size) { return MemoryView<T>(ptr, size); }
 
    template<typename T> MemoryView<const T> make_memory_view(const T* ptr, size_t size) { return MemoryView<const T>(ptr, size); }
 
    template<typename T, size_t N> MemoryView<T> make_memory_view(T (&array)[N]) { return MemoryView<T>(array, N); }
 
    template<typename Container> MemoryView<typename Container::value_type> make_memory_view(Container& container, size_t offset = 0) {
        return MemoryView<typename Container::value_type>(container.data() + offset, container.size() - offset);
    }
 
    template<typename Container> MemoryView<const typename Container::value_type> make_memory_view(const Container& c, size_t offset = 0) {
        return MemoryView<const typename Container::value_type>(c.data() + offset, c.size() - offset);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    using ByteMemoryView = MemoryView<Byte>;
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    namespace impl {
        template<typename T> T* advanceBytes(T* pointer, std::ptrdiff_t bytes) {
            using ByteType = std::conditional_t<std::is_const_v<T>, const Byte, Byte>;
            return reinterpret_cast<T*>(reinterpret_cast<ByteType*>(pointer) + bytes);
        }
    } // namespace impl
 
    template<typename T> class StridedMemoryView {
    public:
        template<bool IsConstIterator> class IteratorImpl;
 
        using value_type = T;
        using size_type = size_t;
        using difference_type = ptrdiff_t;
        using reference = T&;
        using const_reference = const T&;
        using pointer = T*;
        using const_pointer = const T*;
        using iterator = IteratorImpl<false>;
        using const_iterator = IteratorImpl<true>;
        using reverse_iterator = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
        using ValueType = value_type;
        using SizeType = size_type;
        using DifferenceType = difference_type;
        using Reference = reference;
        using ConstReference = const_reference;
        using Pointer = pointer;
        using ConstPointer = const_pointer;
        using Iterator = iterator;
        using ConstIterator = const_iterator;
        using ReverseIterator = reverse_iterator;
        using ConstReverseIterator = const_reverse_iterator;
 
        static constexpr bool isConst = std::is_const_v<T>;
        static constexpr SizeType defaultStride = sizeof(T);
 
    private:
        Pointer mPointer = nullptr;
        SizeType mSize = 0;
        SizeType mStride = 0;
 
    public:
        StridedMemoryView() = default;
 
        StridedMemoryView(std::nullptr_t) {}
 
        StridedMemoryView(const Pointer ptr, const SizeType size, const SizeType stride) : mPointer(ptr), mSize(size), mStride(stride) {}
 
        template<typename U> explicit StridedMemoryView(const StridedMemoryView<U>& view) : StridedMemoryView(view.template as<T>()) {}
 
        StridedMemoryView(const StridedMemoryView&) = default;
        StridedMemoryView(StridedMemoryView&&) = default;
 
        StridedMemoryView& operator=(const StridedMemoryView&) = default;
        StridedMemoryView& operator=(StridedMemoryView&&) = default;
 
        void reset(T* ptr = nullptr, const SizeType size = 0, const SizeType stride = defaultStride) {
            mPointer = ptr;
            mSize = size;
            mStride = stride;
        }
 
        void reset(const SizeType size, const SizeType stride = defaultStride) {
            mSize = size;
            mStride = stride;
        }
 
        [[nodiscard]] StridedMemoryView<T> slice(SizeType offset, SizeType length) const {
            if(offset > mSize) {
                offset = mSize;
                length = 0;
            } else if((offset + length) > mSize) {
                length = mSize - offset;
            }
 
            CE_ASSERT(mSize >= (offset + length));
            return StridedMemoryView<T>(impl::advanceBytes(mPointer, offset * mStride), length, mStride);
        }
 
        explicit operator bool() const { return !!mPointer; }
 
        [[nodiscard]] Pointer get() noexcept requires(!isConst)
        {
            return mPointer;
        }
 
        [[nodiscard]] ConstPointer get() const noexcept { return mPointer; }
 
        [[nodiscard]] Reference at(SizeType i) requires(!isConst)
        {
            CE_MEMORY_VIEW_BOUNDS_CHECK(i);
            return *impl::advanceBytes(mPointer, i * mStride);
        }
 
        [[nodiscard]] ConstReference at(SizeType i) const {
            CE_MEMORY_VIEW_BOUNDS_CHECK(i);
            return *impl::advanceBytes(mPointer, i * mStride);
        }
 
        [[nodiscard]] ConstReference operator[](const SizeType i) const { return at(i); }
 
        [[nodiscard]] Reference operator[](const SizeType i) requires(!isConst)
        {
            return at(i);
        }
 
        [[nodiscard]] ConstReference front() const { return at(0); }
 
        [[nodiscard]] Reference front() requires(!isConst)
        {
            return at(0);
        }
 
        [[nodiscard]] ConstReference back() const { return at(mSize - 1); }
 
        [[nodiscard]] Reference back() requires(!isConst)
        {
            return at(mSize - 1);
        }
 
        [[nodiscard]] Pointer data() const noexcept { return mPointer; }
 
        [[nodiscard]] Pointer data() noexcept { return mPointer; }
 
    public: // Iterators
        [[nodiscard]] Iterator begin() noexcept requires(!isConst)
        {
            return iterator{this, 0};
        }
 
        [[nodiscard]] ConstIterator begin() const noexcept { return const_iterator{this, 0}; }
 
        [[nodiscard]] ConstIterator cbegin() const noexcept { return const_iterator{this, 0}; }
 
        [[nodiscard]] Iterator end() noexcept requires(!isConst)
        {
            return iterator{this, mSize};
        }
 
        [[nodiscard]] ConstIterator end() const noexcept { return const_iterator{this, mSize}; }
 
        [[nodiscard]] ConstIterator cend() const noexcept { return const_iterator{this, mSize}; }
 
        [[nodiscard]] ReverseIterator rbegin() noexcept requires(!isConst)
        {
            return ReverseIterator(end());
        }
 
        [[nodiscard]] ConstReverseIterator rbegin() const noexcept { return ConstReverseIterator(end()); }
 
        [[nodiscard]] ConstReverseIterator crbegin() const noexcept { return ConstReverseIterator(end()); }
 
        [[nodiscard]] ReverseIterator rend() noexcept requires(!isConst)
        {
            return ReverseIterator(begin());
        }
 
        [[nodiscard]] ConstReverseIterator rend() const noexcept { return ConstReverseIterator(begin()); }
 
        [[nodiscard]] ConstReverseIterator crend() const noexcept { return ConstReverseIterator(begin()); }
 
    public: // Capacity
        [[nodiscard]] bool empty() const noexcept { return mSize == 0; }
 
        [[nodiscard]] SizeType size() const noexcept { return mSize; }
 
        [[nodiscard]] SizeType stride() const noexcept { return mStride; }
 
        [[nodiscard]] SizeType byteSize() const noexcept { return mSize * mStride; }
 
        template<typename U> [[nodiscard]] StridedMemoryView<U> as() const noexcept {
            return StridedMemoryView<U>(reinterpret_cast<U*>(mPointer), mSize * sizeof(T) / sizeof(U), mStride);
        }
 
        template<bool IsConstIterator> class IteratorImpl {
        public:
            using Self = std::conditional_t<IsConstIterator, const StridedMemoryView, StridedMemoryView>;
 
            using iterator_category = std::random_access_iterator_tag;
            using difference_type = std::ptrdiff_t;
            using value_type = typename Self::value_type;
            using pointer = typename Self::pointer;
            using const_pointer = typename Self::const_pointer;
            using reference = typename Self::reference;
            using const_reference = typename Self::const_reference;
 
            using DifferenceType = difference_type;
            using ValueType = value_type;
            using Pointer = pointer;
            using ConstPointer = const_pointer;
            using Reference = reference;
            using ConstReference = const_reference;
 
            Self* mMemoryView = nullptr;
            SizeType mIndex = 0;
 
        public:
            explicit IteratorImpl(Self& memoryView, const SizeType index = 0) : mMemoryView(&memoryView), mIndex(index) {}
            explicit IteratorImpl(Self* memoryView, const SizeType index = 0) : mMemoryView(memoryView), mIndex(index) {}
 
            reference operator*() const noexcept requires(!IsConstIterator)
            {
                return (*mMemoryView)[mIndex];
            }
            const_reference operator*() const noexcept requires(IsConstIterator)
            {
                return (*mMemoryView)[mIndex];
            }
 
            pointer operator->() const noexcept requires(!IsConstIterator)
            {
                return &(*mMemoryView)[mIndex];
            }
            const_pointer operator->() const noexcept requires(IsConstIterator)
            {
                return &(*mMemoryView)[mIndex];
            }
 
            IteratorImpl operator++(int) noexcept {
                IteratorImpl copy = *this;
                mIndex++;
                return copy;
            }
 
            IteratorImpl& operator++() noexcept {
                mIndex++;
                return *this;
            }
 
            IteratorImpl operator+(const DifferenceType n) noexcept {
                IteratorImpl copy = *this;
                mIndex = std::clamp(mIndex + n, 0, mMemoryView->size());
                return copy;
            }
 
            IteratorImpl operator--(int) noexcept {
                IteratorImpl copy = *this;
                if(mIndex == 0) {
                    return copy;
                }
 
                mIndex--;
                return copy;
            }
 
            IteratorImpl& operator--() noexcept {
                if(mIndex == 0) {
                    return *this;
                }
                mIndex--;
                return *this;
            }
 
            IteratorImpl operator-(const DifferenceType n) noexcept {
                IteratorImpl copy = *this;
                mIndex = std::clamp(mIndex - n, 0, mMemoryView->size());
                return copy;
            }
 
            friend bool operator==(const IteratorImpl& lhs, const IteratorImpl& rhs) { return rhs.mMemoryView == lhs.mMemoryView && lhs.mIndex == rhs.mIndex; }
 
            friend bool operator!=(const IteratorImpl& lhs, const IteratorImpl& rhs) { return !(lhs == rhs); }
        };
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> StridedMemoryView<T> make_strided_memory_view(T* ptr, size_t size, size_t stride = StridedMemoryView<T>::defaultStride) {
        return StridedMemoryView<T>(ptr, size, stride);
    }
 
    template<typename T> StridedMemoryView<const T> make_strided_memory_view(const T* ptr, size_t size, size_t stride = StridedMemoryView<T>::defaultStride) {
        return StridedMemoryView<const T>(ptr, size, stride);
    }
 
    template<typename T, size_t N> StridedMemoryView<const T> make_strided_memory_view(const T (&ar)[N]) { return StridedMemoryView<const T>(ar, N); }
 
    template<typename Container> StridedMemoryView<typename Container::value_type> make_strided_memory_view(Container& container, size_t offset = 0) {
        return StridedMemoryView<typename Container::value_type>(container.data() + offset, container.size() - offset);
    }
 
    template<typename Container>
    StridedMemoryView<const typename Container::value_type> make_strided_memory_view(const Container& container, size_t offset = 0) {
        return StridedMemoryView<const typename Container::value_type>(container.data() + offset, container.size() - offset);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    using ByteStridedMemoryView = StridedMemoryView<Byte>;
 
} // namespace CeresEngine