Base.h

#pragma once
#include <UnCompute/Base/Logger.h>
#include <UnCompute/Base/Platform.h>
#include <UnCompute/Base/ResultCode.h>
#include <atomic>
#include <cassert>
#include <cstdint>
#include <string_view>
 
namespace UN
{
    using Int8  = int8_t;
    using Int16 = int16_t;
    using Int32 = int32_t;
    using Int64 = int64_t;
 
    using UInt8  = uint8_t;
    using UInt16 = uint16_t;
    using UInt32 = uint32_t;
    using UInt64 = uint64_t;
 
    using Float32 = float;
    using Float64 = double;
 
    using USize = size_t;    
    using SSize = ptrdiff_t; 
 
    inline constexpr struct
    {
        int Major = 0, Minor = 1, Patch = 0;
    } UnComputeVersion; 
 
    template<class T, class = std::enable_if_t<std::is_integral_v<T>, void>>
    class MemorySizeImpl
    {
        T m_SizeInBytes = 0;
 
    public:
        inline MemorySizeImpl() = default;
 
        inline explicit MemorySizeImpl(T sizeInBytes)
            : m_SizeInBytes(sizeInBytes)
        {
        }
 
        template<class T1>
        inline MemorySizeImpl& operator=(const MemorySizeImpl<T1>& other)
        {
            m_SizeInBytes = static_cast<T>(other.m_SizeInBytes);
        }
 
        inline MemorySizeImpl& operator=(const MemorySizeImpl& other)     = default;
        inline MemorySizeImpl& operator=(MemorySizeImpl&& other) noexcept = default;
 
        inline MemorySizeImpl& operator=(const T& other)
        {
            m_SizeInBytes = other;
            return *this;
        }
 
        inline T GetBytes() const
        {
            return m_SizeInBytes;
        }
    };
 
    using MemorySize   = MemorySizeImpl<USize>;
    using MemorySize32 = MemorySizeImpl<UInt32>;
    using MemorySize64 = MemorySizeImpl<UInt64>;
 
    namespace Internal
    {
        struct SVWrapper
        {
            std::string_view value; 
        };
 
        inline constexpr std::string_view TrimTypeName(std::string_view name)
        {
            name.remove_prefix(name.find_first_not_of(' '));
            name.remove_suffix(name.length() - name.find_last_not_of(' ') - 1);
            return name;
        }
 
        template<class T>
        inline constexpr SVWrapper TypeNameImpl()
        {
#if UN_COMPILER_MSVC
            std::string_view fn = __FUNCSIG__;
            fn.remove_prefix(fn.find_first_of("<") + 1);
            fn.remove_suffix(fn.length() - fn.find_last_of(">"));
#else
            std::string_view fn = __PRETTY_FUNCTION__;
            fn.remove_prefix(fn.find_first_of('=') + 1);
            fn.remove_suffix(fn.length() - fn.find_last_of(']'));
#endif
            return SVWrapper{ TrimTypeName(fn) };
        }
    } // namespace Internal
 
    template<class T>
    inline constexpr std::string_view TypeName()
    {
        return Internal::TypeNameImpl<T>().value;
    }
 
    inline constexpr USize MaximumAlignment = 16;
 
    template<class T, class U = T>
    inline T AlignUp(T x, U align)
    {
        return (x + (align - 1u)) & ~(align - 1u);
    }
 
    template<class T>
    inline T* AlignUpPtr(const T* x, USize align)
    {
        return reinterpret_cast<T*>(AlignUp(reinterpret_cast<USize>(x), align));
    }
 
    template<UInt32 A, class T>
    inline constexpr T AlignUp(T x)
    {
        return (x + (A - 1)) & ~(A - 1);
    }
 
    template<class T, class U = T>
    inline T AlignDown(T x, U align)
    {
        return (x & ~(align - 1));
    }
 
    template<class T>
    inline constexpr T* AlignDownPtr(const T* x, USize align)
    {
        return reinterpret_cast<T*>(AlignDown(reinterpret_cast<USize>(x), align));
    }
 
    template<UInt32 A, class T>
    inline constexpr T AlignDown(T x)
    {
        return (x & ~(A - 1));
    }
 
    template<class T>
    inline constexpr T MakeMask(T bitCount, T leftShift)
    {
        auto typeBitCount = sizeof(T) * 8;
        auto mask         = bitCount == typeBitCount ? static_cast<T>(-1) : ((1 << bitCount) - 1);
        return static_cast<T>(mask << leftShift);
    }
 
    inline void HashCombine(std::size_t& /* seed */) {}
 
    template<typename T, typename... Args>
    inline void HashCombine(std::size_t& seed, const T& value, const Args&... args)
    {
        std::hash<T> hasher;
        seed ^= hasher(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
        HashCombine(seed, args...);
    }
 
#define UN_MAKE_HASHABLE(TypeName, Template, ...)                                                                                \
    namespace std                                                                                                                \
    {                                                                                                                            \
        template<Template>                                                                                                       \
        struct hash<TypeName>                                                                                                    \
        {                                                                                                                        \
            inline size_t operator()(const TypeName& value) const noexcept                                                       \
            {                                                                                                                    \
                size_t seed = 0;                                                                                                 \
                ::UN::HashCombine(seed, __VA_ARGS__);                                                                            \
                return seed;                                                                                                     \
            }                                                                                                                    \
        };                                                                                                                       \
    }
 
#if UN_DEBUG
    inline constexpr bool ValidationEnabled = true;
#else
    inline constexpr bool ValidationEnabled = false;
#endif
 
    template<class TDest, class TSrc>
    inline std::enable_if_t<std::is_base_of_v<std::remove_pointer_t<TSrc>, std::remove_pointer_t<TDest>>
                                && std::is_pointer_v<TSrc> && std::is_pointer_v<TDest>,
                            TDest>
    un_verify_cast(TSrc pSourceObject)
    {
        if constexpr (std::is_same_v<TSrc, TDest>)
        {
            return pSourceObject;
        }
 
        if constexpr (ValidationEnabled) // NOLINT
        {
            if (auto* result = dynamic_cast<TDest>(pSourceObject))
            {
                return result;
            }
 
            UN_Assert(false, "Verifying cast failed");
        }
 
        return static_cast<TDest>(pSourceObject);
    }
} // namespace UN
 
template<class T>
struct fmt::formatter<UN::MemorySizeImpl<T>> : fmt::formatter<std::string_view>
{
    template<typename FormatContext>
    auto format(const UN::MemorySizeImpl<T>& size, FormatContext& ctx) const -> decltype(ctx.out())
    {
        UN::Int32 i = 0;
        auto bytes  = static_cast<UN::Float64>(size.GetBytes());
 
        const char* units[] = { "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
        while (bytes >= 1024)
        {
            bytes /= 1024;
            i++;
        }
 
        return fmt::format_to(ctx.out(), "{:.2f}{}", bytes, units[i]);
    }
};