AuROXTL/Include/auROXTL/auMemoryModel.hpp

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

    File: auMemoryModel.hpp
    Date: 2022-2-1
    File: AuroraUtils.hpp
    File: auROXTLUtils.hpp
    Date: 2021-6-9
    Author: Reece
***/
#pragma once

#include "auTypes.hpp"

#if !defined(AURORA_RUNTIME_AU_SHARED_PTR)
    #define AURORA_RUNTIME_AU_SHARED_PTR std::shared_ptr
#endif

#if !defined(AURORA_RUNTIME_AU_WEAK_PTR)
    #define AURORA_RUNTIME_AU_WEAK_PTR std::weak_ptr
#endif

template <class T>
using AuWPtr = AURORA_RUNTIME_AU_WEAK_PTR<T>;

#if !defined(AURORA_RUNTIME_AU_UNIQUE_PTR)
    #define AURORA_RUNTIME_AU_UNIQUE_PTR std::unique_ptr
#endif

#if !defined(AURORA_RUNTIME_AU_DEFAULT_DELETER)
    #define AURORA_RUNTIME_AU_DEFAULT_DELETER std::default_delete
#endif

template <class T>
using AuDefaultDeleter = AURORA_RUNTIME_AU_DEFAULT_DELETER<T>;

#include "STLShims/ExtendStlLikeSharedPtr.hpp"

template <class T>
using AuSPtr = typename Aurora::Memory::ExSharedPtr<T, AURORA_RUNTIME_AU_SHARED_PTR<T>>;

template <class T, typename Deleter_t>
using AuUPtr = AURORA_RUNTIME_AU_UNIQUE_PTR<T, Deleter_t>;

#if !defined(AU_AuEnableSharedFromThis)
#define AU_AuEnableSharedFromThis

template <class X>
struct AuEnableSharedFromThis : Aurora::Memory::ExSharedFromThis<X, std::enable_shared_from_this<X>>
{};

#endif

#if !defined(AURORA_RUNTIME_MAKE_SHARED)
    #define AURORA_RUNTIME_MAKE_SHARED std::make_shared
#endif

static inline AU_NORETURN void SysPanic(const char *pMsg);

static auline void AuMemoryPanic(const char *msg)
{
    #if defined(AURORA_RUNTIME_MEMORY_PANIC)
        AURORA_RUNTIME_MEMORY_PANIC(msg);
    #else
        SysPanic(msg);
    #endif
}

template <class T, typename... Args>
static auline AuSPtr<T> AuMakeShared(Args&&... args)
{
    try
    {
        return AURORA_RUNTIME_MAKE_SHARED<T>(AuForward<Args>(args)...);
    }
    catch (...)
    {
        return {};
    }
}

template <class T, typename... Args>
static auline AuSPtr<T> AuMakeSharedPanic(Args&&... args)
{
    try
    {
        auto pShared = AURORA_RUNTIME_MAKE_SHARED<T>(AuForward<Args>(args)...);
        if (!pShared)
        {
            AuMemoryPanic("Failed to allocate <X>"); // TODO: non-rtti typename
        }

        return pShared;
    }
    catch (...)
    {
        AuMemoryPanic("Failed to allocate <X>"); // TODO: non-rtti typename
        return {};
    }
}

template <class T, typename... Args>
static auline AuSPtr<T> AuMakeSharedThrow(Args&&... args)
{
    try
    {
        auto pShared = AURORA_RUNTIME_MAKE_SHARED<T>(AuForward<Args>(args)...);
        if (!pShared)
        {
            // TODO: Agnostic SysPushErrorMemory
            AU_THROW_STRING("Failed to allocate <X>"); // TODO: non-rtti typename
        }

        return pShared;
    }
    catch (...)
    {
        // TODO: Agnostic SysPushErrorCatch
        AU_THROW_STRING("Failed to allocate <X>"); // TODO: non-rtti typename
        return {};
    }
}

namespace __audetail
{
    struct Dummy
    {
        char a;
    };

    inline AuSPtr<Dummy> GetDummyDeleter()
    {
        static AuSPtr<Dummy> d;
        if (!d)
        {
        #if defined(AURORA_COMPILER_MSVC)
            return d;
        #endif
            d = AuMakeShared<Dummy>();
        }
        return d;
    }
}

template <class T>
static auline AuSPtr<T> AuMakeSharedArray(AuUInt count)
{
    try
    {
    #if defined(AU_LANG_CPP_20) && 0
        return AURORA_RUNTIME_AU_SHARED_PTR<T[]>(count);
    #else
        return AURORA_RUNTIME_AU_SHARED_PTR<T>(new T[count], AuDefaultDeleter<T[]>());
    #endif
    }
    catch (...)
    {
        return {};
    }
}

template <class T>
static AuSPtr<T> AuUnsafeRaiiToShared(T *in)
{
    return AuSPtr<T>(__audetail::GetDummyDeleter(), in);
}

template <class T, class Z>
static AuSPtr<T> AuUnsafeRaiiToShared(const AuUPtr<T, Z> &in)
{
    return AuUnsafeRaiiToShared(in.get());
}

template <class T, AuUInt Z>
static constexpr AuUInt AuArraySize(const T(&array)[Z])
{
    return Z;
}

template <typename T, typename C>
static AuUInt AuOffsetOf(C T:: *offset)
{
    return AuUInt(
        &(((const T *)(nullptr))->*offset)
    );
}

template <typename T>
static auto AuTryLockMemoryType(T weak) -> decltype(weak.lock())
{
    if (weak.expired())
    {
        return {};
    }

    AUROXTL_COMMODITY_TRY
    {
        return weak.lock();
    }
    AUROXTL_COMMODITY_CATCH
    {
        return {};
    }
}

template <typename T>
constexpr AuUInt AuSizeOf()
{
    return sizeof(T);
}

template <typename T>
constexpr AuUInt AuSizeOf(const T &)
{
    return sizeof(T);
}

template <typename T>
constexpr AuUInt AuSizeOf(const T *)
{
    return sizeof(T);
}

template <typename T>
constexpr AuUInt AuSizeOf(const AuSPtr<T>)
{
    return sizeof(T);
}

template <class Z, typename T>
static void auline AuSafeDelete(T *in)
{
    static_assert(AuIsBaseOf_v<T, AuRemovePointer_t<Z>>, "Couldn't not safe delete from type T because it is not derived from Z");

    if (in == nullptr)
    {
        return;
    }

    delete static_cast<Z>(in);
}


// TODO: Move me
#include "auOptional.hpp"
#include "auCastUtils.hpp"

namespace Aurora::Memory
{
#if defined(AURORA_ROXTL_ALLOCATORS_USE_STD)

    template<typename T>
    using PrimitiveArrayAllocator =  std::allocator<T>;
    
    template<typename T>
    using ClassArrayAllocator     =  std::allocator<T>;
    
    template<typename T>
    using StringAllocator         =  std::allocator<T>;
    
#else

    static void *__FAlloc(Types::size_t length, Types::size_t align);
    static void  __Free(void *buffer);

    template <class T>
    struct BaseAuroraRuntimeAllocator
    {
        typedef T value_type;

        AU_COPY_MOVE(BaseAuroraRuntimeAllocator)

        constexpr BaseAuroraRuntimeAllocator()
        {}

        template <class U> constexpr BaseAuroraRuntimeAllocator(const BaseAuroraRuntimeAllocator <U> &) noexcept
        {
        }

        inline constexpr T* allocate(Types::size_t n)
        {
            if (auto p = (__FAlloc(n * sizeof(T), alignof(T))))
            {
                return AuReinterpretCast<T*>(p);
            }

            throw std::bad_alloc();
        }

        inline constexpr void deallocate(T *p, std::size_t n) noexcept
        {
            __Free(p);
        }

        inline bool operator==(const BaseAuroraRuntimeAllocator &op)
        {
            return true;
        }
    };
    
    
    template<typename T>
    using PrimitiveArrayAllocator =  BaseAuroraRuntimeAllocator<T>;
    
    template<typename T>
    using ClassArrayAllocator     =  BaseAuroraRuntimeAllocator<T>;
    
    template<typename T>
    using StringAllocator         =  BaseAuroraRuntimeAllocator<T>;
   
#endif
}

namespace AuHash
{
    template <class T>
    struct hash<AuSPtr<T>>
    {
        AuUInt operator ()(const AuSPtr<T> &ptr) const
        {
        #if defined(AURORA_IS_32BIT)
            return ComputeUnseededHash(AuUInt(ptr.get()));
        #else
            return ComputeLongHash(AuUInt(ptr.get()));
        #endif
        }
    };
}