AuroraRuntime/Include/Aurora/Memory/Heap.hpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: Heap.hpp
    Date: 2021-6-9
    Author: Reece
***/
#pragma once

namespace Aurora::Memory
{
    struct Heap
    {
        virtual AuSPtr<Heap> AllocateDivision(AuUInt32 heap, AuUInt32 alignment = 32) = 0;
        virtual Types::size_t GetChunkSize(const void *head) = 0;
        virtual HeapStats &GetStats() = 0;

        template<typename T = void *>
        T ZAlloc(Types::size_t length)
        {
            return reinterpret_cast<T>(_ZAlloc(length));
        }

        template<typename T = void *>
        T ZAlloc(Types::size_t length, Types::size_t align)
        {
            return reinterpret_cast<T>(_ZAlloc(length, align));
        }

        template<typename T>
        T *ZAlloc()
        {
            return reinterpret_cast<T *>(_ZAlloc(sizeof(T)));
        }

        template<typename T>
        T *NewArray(Types::size_t count)
        {
            return ZAlloc<T *>(count * sizeof(T));
        }

        template<typename T>
        T *NewArray(Types::size_t count, Types::size_t align)
        {
            return ZAlloc<T *>(count * sizeof(T), align);
        }

        /// Fast, unsafe alloc
        template<typename T = void *>
        T FAlloc(Types::size_t length)
        {
            return reinterpret_cast<T>(_FAlloc(length));
        }

        template<typename T = void *>
        T FAlloc(Types::size_t length, Types::size_t align)
        {
            return reinterpret_cast<T>(_FAlloc(length, align));
        }

        template<typename T>
        T ZRealloc(T in, Types::size_t length)
        {
            return reinterpret_cast<T>(_ZRealloc(reinterpret_cast<void *>(in), length));
        }

        template<typename T>
        T ZRealloc(T in, Types::size_t length, Types::size_t alloc)
        {
            return reinterpret_cast<T>(_ZRealloc(reinterpret_cast<void *>(in), length), alloc);
        }

        template<typename T>
        T FRealloc(T in, Types::size_t length)
        {
            return reinterpret_cast<T>(_FRealloc(reinterpret_cast<void *>(in), length));
        }

        template<typename T>
        T FRealloc(T in, Types::size_t length, Types::size_t alloc)
        {
            return reinterpret_cast<T>(_FRealloc(reinterpret_cast<void *>(in), length), alloc);
        }

        template<typename T>
        void Free(T in)
        {
            _Free(reinterpret_cast<void *>(in));
        }

        template <class T, class ...Args>
        AuSPtr<T> NewClass(Args &&...args)
        {
            void *pPtr;

            if constexpr (AuIsClass_v<T>)
            {
                pPtr = this->FAlloc<void *>(sizeof(T));
                if (pPtr)
                {
                    new (pPtr) T(AuForward<Args &&>(args)...);
                }
            }
            else
            {
                pPtr = this->ZAlloc<void *>(sizeof(T));
            }

            if (!pPtr)
            {
                return {};
            }

            return ToSmartPointer((T *)pPtr, true);
        }


        /**
         * @brief 
         * @param in
         *  A pointer owned by the heap
         * @param pinThis
         *  If you attempt to destroy a heap, or allow a shared ptr to free the heap w/o freeing all allocations, the heap will dangle and a telemetry warning will be sent.
         *  pinThis isn't strictly needed unless you wish to slience heap freed before allocation warnings.
         *  A memory management model whereby you dont pin the parent heap will prevent circular references from taking over; in contrast, the alternative will need well defined object disposal
         *  One could keep heap references weak outside of your heap manager and always pin this - or you could pin nothing and be careful with object disposal order
         * @return 
        */
        template<typename T>
        AuSPtr<T> ToSmartPointer(T *in, bool pinThis)
        {
            if (in == nullptr) return {};
            auto heapHandle = pinThis ? GetSelfReference() : AuSPtr<Heap> {};
            return AuSPtr<T>(in,
                   [heapHandle, in, this](T *delt)
                   {
                       if constexpr (AuIsClass_v<T>)
                       {
                           delt->~T();
                       }
                       this->Free(delt);
                   });
        }

        template<typename T>
        static AuSPtr<T> ToSmartPointer(AuSPtr<Heap> heap, T *in, bool pinHeap = true)
        {
            auto handle = pinHeap ? heap : AuSPtr<Heap> {};
            auto ptr = heap.get(); // so long as in is a valid pointer within the heap, this is fine
            return AuSPtr<T>(in,
                   [handle,  ptr](T *delt)
                   {
                        if constexpr (AuIsClass_v<T>)
                        {
                            delt->~T();
                        }

                        ptr->Free(delt);
                   });
        }

    private:

        virtual AuSPtr<Heap> GetSelfReference() = 0; // may return empty/default. not all heaps are sharable.

        virtual AU_ALLOC void *_ZAlloc(Types::size_t uLength) = 0;
        virtual AU_ALLOC void *_ZAlloc(Types::size_t uLength, Types::size_t align) = 0;
        virtual AU_ALLOC void *_FAlloc(Types::size_t uLength) = 0;
        virtual AU_ALLOC void *_FAlloc(Types::size_t uLength, Types::size_t align) = 0;
        virtual AU_ALLOC void *_ZRealloc(void *pBase, Types::size_t uLength, Types::size_t uAlign) = 0;
        virtual AU_ALLOC void *_ZRealloc(void *pBase, Types::size_t uLength) = 0;
        virtual AU_ALLOC void *_FRealloc(void *pBase, Types::size_t uLength, Types::size_t uAlign) = 0;
        virtual AU_ALLOC void *_FRealloc(void *pBase, Types::size_t uLength) = 0;
        virtual void           _Free(void* pBase) = 0;
    };

    /**
        Returns a heap interface backed by the default allocator
    */
    AUKN_SHARED_API(GetDefaultDiscontiguousHeap, Heap);

    /**
        Allocates Fize amount of memory

        NOTE -> Heaps are guaranteed to outlive its' allocations; heap are the one object that own themselves
                Destructions are mere suggestions, however, requesting termination before a heap has released all of its memory will result in a telemetry mayday 

        @return a heap backed by allocated memory
    */
    AUKN_SHARED_API(AllocHeap, Heap, AuUInt uLength);

    AUKN_SHARED_API(RequestHeapOfRegion, Heap, void *pPtr, AuUInt uLength);

    AUKN_SHARED_API(AllocHeapMimalloc, Heap, AuUInt uLength);
}