DCS_ModuleUtils.h

Go to the documentation of this file.

#ifndef _DCS_UTILS_H
#define _DCS_UTILS_H

#pragma once
#include "../../config/exports.h"
#include <iostream>
#include <chrono>
#include <mutex>
#include <map>
#include <string>
#include <future>

#ifdef SOURCE_PATH_SIZE
#define LOG_LVL(lvl, msg, ...) DCS::Utils::Logger::lvl(__FILE__ + SOURCE_PATH_SIZE, msg, __VA_ARGS__) 
#else 
#define LOG_LVL(lvl, msg, ...) DCS::Utils::Logger::lvl(__FILE__, msg, __VA_ARGS__) 
#endif

#define LOG_DEBUG(msg, ...) LOG_LVL(Debug, msg, __VA_ARGS__) 
#define LOG_MESSAGE(msg, ...) LOG_LVL(Message, msg, __VA_ARGS__) 
#define LOG_WARNING(msg, ...) LOG_LVL(Warning, msg, __VA_ARGS__) 
#define LOG_ERROR(msg, ...) LOG_LVL(Error, msg, __VA_ARGS__) 
#define LOG_CRITICAL(msg, ...) LOG_LVL(Critical, msg, __VA_ARGS__) 

#define ENUM_FLAG_OPERATOR(T,X) inline T operator X (T lhs, T rhs) { return (T) (static_cast<std::underlying_type_t <T>>(lhs) X static_cast<std::underlying_type_t <T>>(rhs)); } 
#define ENUM_FLAGS(T) \
enum class T; \
inline T operator ~ (T t) { return (T) (~static_cast<std::underlying_type_t <T>>(t)); } \
ENUM_FLAG_OPERATOR(T,|) \
ENUM_FLAG_OPERATOR(T,^) \
ENUM_FLAG_OPERATOR(T,&) \
enum class T

namespace DCS
{
    typedef signed long long i64; 
    typedef unsigned long long u64; 
    typedef signed long i32; 
    typedef unsigned long u32; 
    typedef short i16; 
    typedef unsigned short u16; 
    typedef signed char i8; 
    typedef unsigned char u8; 

    typedef float f32; 
    typedef double f64; 

    typedef void* GenericHandle;

    namespace Utils
    {
        class DCS_API String
        {
        public:
            String() = default;

            String(const char* text);
            String(const String& s);

            ~String();

            String& operator=(const String& s) noexcept;

            inline const size_t size() const
            {
                return buffer_size;
            }

            template<typename T>
            static inline const String From(T val)
            {
                return String(std::to_string(val).c_str());
            }

            inline const char* c_str() const
            {
                return buffer;
            }

        private:
            size_t buffer_size = 0;
            char* buffer = nullptr;
        };

        struct DCS_API BasicString
        {
            char buffer[512]; 
        };

        class Logger
        {
        public:
            enum class Verbosity : int;
        private:
            
            typedef void (*WriteNotifyCallback)(DCS::Utils::String string, Verbosity v, void*);

        public:
            enum class Verbosity
            {
                CRITICAL, 
                ERROR,    
                WARNING,  
                MESSAGE,  
                DEBUG     
            };

            enum class Options
            {
                ENABLE_COLOR, 
                DISABLE_COLOR 
            };

            static DCS_API void Init(Verbosity level, DCS::Utils::String file = "default_log.log");

            static DCS_API void Destroy();

            static DCS_API void SetLogWriteCallback(WriteNotifyCallback wnc, void* obj = nullptr);

            static DCS_API void Debug(const char* file, const char* msg, ...);

            static DCS_API void Message(const char* file, const char* msg, ...);

            static DCS_API void Warning(const char* file, const char* msg, ...);

            static DCS_API void Error(const char* file, const char* msg, ...);

            static DCS_API void Critical(const char* file, const char* msg, ...);

            static DCS_API void Settings(Options opt);

            static DCS_API void ChangeVerbosity(Verbosity v);

        private:
            static void WriteData(std::string buffer[], Verbosity v);

            static WriteNotifyCallback writenotify;
            static void* obj;

            static Verbosity verbosity_level;
            static Options options;
            static std::string timestamp();
            static FILE* handle;
            static std::mutex _log_mtx;
        };

        template<typename T>
        class AsyncItem
        {
        public:
            AsyncItem(std::promise<T>& p) { f = p.get_future(); };
            ~AsyncItem() = default;

            inline void wait() const
            {
                f.wait();
            }

            inline T get() const
            {
                return f.get();
            }

        private:
            std::shared_future<T> f;
        };
    }

    namespace Timer
    {
        struct DCS_API SystemTimer
        {
            GenericHandle point; 
        };

        struct DCS_API Timestamp
        {
            i16 hour = 0; 
            i16 min = 0; 
            i16 sec = 0; 
            i16 millis = 0; 
            i16 micros = 0; 
            i16 nanos = 0; 

            const Utils::String to_string() const;
        };

        DCS_API SystemTimer New();

        DCS_API void Delete(SystemTimer timer);

        DCS_API Timestamp GetTimestamp(SystemTimer timer);

        DCS_API Utils::String GetTimestampString(SystemTimer timer);

        DCS_API Utils::String GetTimestampStringSimple(SystemTimer timer);

        DCS_API i64 GetNanoseconds(SystemTimer timer);
    }
}

#endif _DCS_UTILS_H