Debug.hpp

#pragma once
#include "SpinLock.hpp"
#include "PhysXDefines.h"
#include "Format.hpp"
 
namespace RavEngine {
 
class Debug{
private:
    Debug() = delete;
    static SpinLock mtx;
    constexpr static uint16_t bufsize = 512;
 
    static void LogHelper(FILE* output, const std::string_view, const char* type);
    
    static void InvokeUserHandler(const std::string_view msg);
    
public:
    
    static inline void LogTemp(const std::string_view message){
#ifndef NDEBUG
        LogHelper(stdout, message, "LOGTEMP");
#endif
    }
    
    template <typename ... T>
    static inline void LogTemp(const std::string_view formatstr, T&& ... values){
#ifndef NDEBUG
        LogHelper(stdout, Format(formatstr,values...),"LOGTEMP");
#endif
    }
    
    static inline void Log(const std::string_view message){
        LogHelper(stdout, message, "LOG");
    }
    
    template <typename ... T>
    static constexpr inline void Log(const std::string_view formatstr, T&& ... values){
        LogHelper(stdout, VFormat(formatstr, values...),"LOG");
    }
    
    static inline void Warning(const char* message){
        LogHelper(stderr, message, "WARN");
    }
    
    template <typename ... T>
    static inline void Warning(const std::string_view formatstr, T&& ... values){
        LogHelper(stderr, VFormat(formatstr, values...), "WARN");
    }
    
    static inline void PrintStacktraceHere(){
        //TODO: get stack trace and print
    }
    
    static inline void Error(const std::string_view message){
        LogHelper(stderr, message, "ERROR");
        PrintStacktraceHere();
    }
    
    template <typename ... T>
    static inline void Error(const std::string_view formatstr, T&& ... values){
        LogHelper(stderr, VFormat(formatstr, values...), "ERROR");
        PrintStacktraceHere();
    }
    
    static inline void Fatal(const std::string_view message){
        Debug::Error(message);
        InvokeUserHandler(message);
        throw std::runtime_error(std::string(message));
    }
    
    template <typename ... T>
    static inline void Fatal(const std::string_view formatstr, T&& ... values){
        Debug::Error(formatstr,values...);
        auto formattedMsg = VFormat(formatstr, values...);
        InvokeUserHandler(formattedMsg);
        throw std::runtime_error(formattedMsg);
    }
    
    template <typename ... T>
    static inline void Assert(bool condition, const char* formatstr, T&& ... values){
        if (!condition){
            Fatal(formatstr,values...);
        }
    }
    
    static inline void Assert(bool condition, const char* msg){
        if (!condition){
            Fatal(msg);
        }
    }
    
    template<typename U,typename T>
    static inline U AssertSize(T val, const char* name = ""){
        Debug::Assert(val <=  std::numeric_limits<U>::max(), "Size ({}) is greater than maximum allowed ({})",val, std::numeric_limits<U>::max());
        return static_cast<U>(val);
    }
};
    
}