memory.h

 
#pragma once
 
#include <system/array.h>
#include <system/span.h>
#include <system/convert.h>
#include <system/buffers/memory_handle.h>
#include <system/buffers/memory_manager.h>
 
namespace System {
namespace Details {
 
template <typename T>
class ArrayMemoryManager : public Buffers::MemoryManager<T>
{
public:
    ArrayMemoryManager(const ArrayPtr<T>& array) : m_array(array) {}
 
    Span<T> GetSpan() override
    {
        return Span<T>(m_array);
    }
 
    Buffers::MemoryHandle Pin(int32_t elementIndex = 0) override
    {
        return Buffers::MemoryHandle(&m_array[elementIndex]);
    }
 
    void Unpin() override
    {
    }
 
protected:
    void Dispose(bool disposing) override
    {
    }
 
private:
    ArrayPtr<T> m_array;
};
 
template <typename T>
class MemoryCore : public Details::BoxableObjectBase
{
public:
    MemoryCore() : m_manager(nullptr), m_start(0), m_length(0)
    {
    }
 
    MemoryCore(const ArrayPtr<T>& array) : MemoryCore(array, 0, array->get_Length())
    {
    }
 
    MemoryCore(const ArrayPtr<T>& array, int32_t start, int32_t length)
        : MemoryCore(System::MakeObject<ArrayMemoryManager<T>>(array), start, length)
    {
    }
 
    MemoryCore(const SharedPtr<Buffers::MemoryManager<T>>& manager, int32_t length) : MemoryCore(manager, 0, length)
    {
    }
 
    MemoryCore(const SharedPtr<Buffers::MemoryManager<T>>& manager, int32_t start, int32_t length)
        : m_manager(manager), m_start(start), m_length(length)
    {
    }
 
    int32_t get_Length() const
    {
        return m_length;
    }
 
    int32_t get_IsEmpty() const
    {
        return m_length == 0;
    }
 
    Buffers::MemoryHandle Pin()
    {
        return m_manager ? m_manager->Pin(m_start) : Buffers::MemoryHandle(nullptr);
    }
 
    ArrayPtr<T> ToArray() const
    {
        return m_manager != nullptr ? m_manager->GetSpan().Slice(m_start, m_length).ToArray() : nullptr;
    }
 
    bool Equals(const MemoryCore& other) const
    {
        return m_manager == other.m_manager && m_start == other.m_start && m_length == other.m_length;
    }
 
    bool GetHashCode() const
    {
        return m_manager ? System::ObjectExt::GetHashCode(m_manager) ^ (m_start << 2) ^ (m_length << 2) : 0;
    }
 
protected:
    SharedPtr<Buffers::MemoryManager<T>> m_manager;
    int32_t m_start;
    int32_t m_length;
};
 
} // namespace Details
 
template <typename T>
class ReadOnlyMemory;
 
template <typename T>
class Memory : public Details::MemoryCore<T>
{
public:
    using Details::MemoryCore<T>::MemoryCore;
 
    Span<T> get_Span() const
    {
        return this->m_manager ? this->m_manager->GetSpan().Slice(this->m_start, this->m_length) : Span<T>();
    }
 
    static Memory get_Empty()
    {
        return Memory();
    }
 
    void CopyTo(const Memory& destination)
    {
        get_Span().CopyTo(destination.get_Span());
    }
 
    bool TryCopyTo(const Memory& destination)
    {
        return get_Span().TryCopyTo(destination.get_Span());
    }
 
    Memory Slice(int32_t start, int32_t length) const
    {
        return Memory(this->m_manager, this->m_start + start, length);
    }
 
    operator ReadOnlyMemory<T>() const
    {
        return ReadOnlyMemory<T>(this->m_manager, this->m_start, this->m_length);
    }
 
    template <typename T1 = T>
    typename std::enable_if<std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return System::String(this->ToArray());
    }
 
    template <typename T1 = T>
    typename std::enable_if<!std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return u"System::Memory<T>[" + System::Convert::ToString(this->m_length) + u"]";
    }
 
    static Memory to_Memory(const ArrayPtr<T>& array)
    {
        return Memory(array);
    }
};
 
template <typename T>
class ReadOnlyMemory : public Details::MemoryCore<T>
{
public:
    using Details::MemoryCore<T>::MemoryCore;
 
    ReadOnlySpan<T> get_Span() const
    {
        return this->m_manager ? ReadOnlySpan<T>(this->m_manager->GetSpan().Slice(this->m_start, this->m_length))
                               : ReadOnlySpan<T>();
    }
 
    static ReadOnlyMemory get_Empty()
    {
        return ReadOnlyMemory();
    }
 
    ReadOnlyMemory Slice(int32_t start, int32_t length) const
    {
        return ReadOnlyMemory(this->m_manager, this->m_start + start, length);
    }
 
    template <typename T1 = T>
    typename std::enable_if<std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return System::String(this->ToArray());
    }
 
    template <typename T1 = T>
    typename std::enable_if<!std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return u"System::ReadOnlyMemory<T>[" + System::Convert::ToString(this->m_length) + u"]";
    }
 
    static ReadOnlyMemory to_ReadOnlyMemory(const ArrayPtr<T>& array)
    {
        return ReadOnlyMemory(array);
    }
};
 
} // namespace System