common.h

Go to the documentation of this file.

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#ifdef DIARKIS_ENABLE_UE_BUILD
 
#include "CoreMinimal.h"
 
#if PLATFORM_WINDOWS
#include "Windows/WindowsSystemIncludes.h"
#include "Windows/AllowWindowsPlatformTypes.h"
#endif
 
THIRD_PARTY_INCLUDES_START
 
#endif // DIARKIS_ENABLE_UE_BUILD
 
#include "diarkis/config.h"
#include "diarkis/diarkis_export.h"
#include "system/stringHash.h"
 
#include <type_traits>
#include <vector>
#include <string>
#include <cstring>
#include <memory>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <atomic>
#include <cassert>
 
#ifdef DIARKIS_ENABLE_UE_BUILD
 
THIRD_PARTY_INCLUDES_END
 
#if PLATFORM_WINDOWS
#include "Windows/HideWindowsPlatformTypes.h"
#endif
 
#endif // DIARKIS_ENABLE_UE_BUILD
 
#ifndef DIARKIS_ENABLE_UE_BUILD
// When the runtime is built as a UE plugin, some interface classes will be exported from the plugin, so we need to specify DIARKIS_API for each class.
// But this macro won't be defined when the runtime is built alone, so we define this macro with empty to commonize the source code between the alone build and the UE build.
#define DIARKIS_API
#endif
 
// A macro suppressing the warning for unused variables by the compiler.
#define DIARKIS_UNUSED(var) (void)var
// The behavior of the macro is the same as DIARKIS_UNUSED, but this macro means there could be a warning in some build configurations only.
#define DIARKIS_UNUSED_IN_RELEASE(var) DIARKIS_UNUSED(var)
 
#define DIARKIS_ASSERT(x, msg) assert(x && msg)
 
#define DIARKIS_AUTHKEY_LEN 16
 
// we might want to move to another header file
struct Credentials {
    uint8_t key[DIARKIS_AUTHKEY_LEN];
    uint8_t iv[DIARKIS_AUTHKEY_LEN];
    uint8_t mac[DIARKIS_AUTHKEY_LEN];
};
struct AuthInfo {
    uint8_t sid[DIARKIS_AUTHKEY_LEN];
    struct Credentials cred;
};
 
// ADD NAMESPACE NAME TAG
namespace Diarkis
{
    static const char* diarkisVersion = "v1.0.0";
 
    inline const char* GetVersion()
    {
        return Diarkis::diarkisVersion;
    }
 
    class DIARKIS_EXPORT ICustomAllocator
    {
    public:
        ICustomAllocator() {}
        virtual ~ICustomAllocator() {}
 
        virtual void* Allocate(size_t size, int flag) = 0;
        virtual void* AlignedAllocate(size_t size, size_t align, int flag) = 0;
        virtual void  Deallocate(void* ptr) = 0;
    };
 
    class DIARKIS_EXPORT DiarkisDefaultAllocator : public ICustomAllocator
    {
    public:
        DiarkisDefaultAllocator();
        virtual ~DiarkisDefaultAllocator();
 
        virtual void* Allocate(size_t size, int flag) override;
        virtual void* AlignedAllocate(size_t size, size_t align, int flag) override;
        virtual void  Deallocate(void* ptr) override;
 
        size_t GetAllocatedSize() const;
 
    private:
        std::atomic<size_t>* allocatedSize_;
        char buff_[sizeof(std::atomic<size_t>)];
    };
 
    class DIARKIS_EXPORT IFixedAreaMemoryAllocator : public ICustomAllocator
    {
    public:
        IFixedAreaMemoryAllocator() : ICustomAllocator() {}
        virtual ~IFixedAreaMemoryAllocator() {}
 
        virtual int Initialize(void* startAddr, std::size_t mainAreaSize, size_t manageAreaSize, std::size_t align) = 0;
        virtual void DeInitialize() = 0;
 
        virtual std::size_t GetAllocatedSize() const = 0;
        virtual void PrintStatistics() const = 0;
 
        static std::size_t GetManageAreaMemorySize(std::size_t size, std::size_t align);
    };
 
    DIARKIS_EXPORT ICustomAllocator* SetCustomAllocator(ICustomAllocator* pAllocator);
 
    DIARKIS_EXPORT DiarkisDefaultAllocator* GetDefaultAllocator();
 
    DIARKIS_EXPORT IFixedAreaMemoryAllocator* GetFixedAreaMemoryAllocator();
 
    DIARKIS_EXPORT void* DiarkisAlloc(size_t size, int flag = 0);
 
    DIARKIS_EXPORT void* DiarkisAlignedAlloc(size_t size, size_t align, int flag = 0);
 
    DIARKIS_EXPORT void DiarkisFree(void* ptr);
 
    template<class T, class... _Types>
    inline T* DiarkisNew(_Types&&... _Args)
    {
        void* pMemory = DiarkisAlloc(sizeof(T));
        return new(pMemory) T(std::forward<_Types>(_Args)...);
    }
 
    template <class T, typename std::enable_if<std::is_array<T>::value, int>::type = 0>
    inline typename std::remove_extent<T>::type* DiarkisNew(const size_t N)
    {
        using _Elem = typename std::remove_extent<T>::type;
        void* pMemory = DiarkisAlloc(sizeof(_Elem) * N);
        return new(pMemory) _Elem[N];
    }
 
    template<class T>
    inline void DiarkisDelete(T* ptr)
    {
        ptr->~T();
        DiarkisFree((void*)(ptr));
    }
 
    template <class T>
    struct DiarkisStdAllocator {
        using value_type = T;
 
        DiarkisStdAllocator() {}
 
        template <class U>
        DiarkisStdAllocator(const DiarkisStdAllocator<U>&) {}
 
        T* allocate(std::size_t n)
        {
            return reinterpret_cast<T*>(DiarkisAlloc(sizeof(T) * n));
        }
 
        void deallocate(T* p, std::size_t n)
        {
            static_cast<void>(n);
            DiarkisFree(p);
        }
    };
 
    template <class T, class U>
    bool operator==(const DiarkisStdAllocator<T>&, const DiarkisStdAllocator<U>&)
    {
        return true;
    }
 
    template <class T, class U>
    bool operator!=(const DiarkisStdAllocator<T>&, const DiarkisStdAllocator<U>&)
    {
        return false;
    }
 
    // deleter for StdUniquePtr
    template<class T>
    struct DiarkisAllocatorDeleter
    {
        constexpr DiarkisAllocatorDeleter() noexcept = default;
 
        template<
            typename U,
            typename std::enable_if<std::is_convertible<U*, T*>::value, std::nullptr_t>::type = nullptr
        >
 
        DiarkisAllocatorDeleter(const DiarkisAllocatorDeleter<U>&) noexcept {}
 
        void operator()(T* ptr) const
        {
            DiarkisDelete(ptr);
        }
    };
 
    // deleter for StdUniquePtr to array of unknown size
    template<class T>
    struct DiarkisAllocatorDeleter<T[]>
    {
        constexpr DiarkisAllocatorDeleter() noexcept = default;
 
        template<
            typename U,
            typename std::enable_if<std::is_convertible<U(*)[], T(*)[]>::value, std::nullptr_t>::type = nullptr
        >
        DiarkisAllocatorDeleter(const DiarkisAllocatorDeleter<U[]>&) noexcept {}
 
        void operator()(T* ptr) const
        {
            DiarkisDelete(ptr);
        }
    };
#if defined(DIARKIS_DISABLE_CUSTOM_ALLOCATOR_FOR_STD_LIBS)
    template<class T>
    using StdUniquePtr = std::unique_ptr<T>;
 
    template <class T, class... _Types, typename std::enable_if<!std::is_array<T>::value, int>::type = 0>
    inline StdUniquePtr<T> DiarkisAllocUnique(_Types&&... _Args)
    {
        return std::move(StdUniquePtr<T>(DiarkisNew<T>(std::forward<_Types>(_Args)...)));
    }
 
    template <class T, typename std::enable_if<std::is_array<T>::value, int>::type = 0>
    inline StdUniquePtr<T> DiarkisAllocUnique(const size_t N)
    {
        return std::move(StdUniquePtr<T>(DiarkisNew<T>(N)));
    }
 
    template<class T, class... _Types>
    inline std::shared_ptr<T> DiarkisAllocShared(_Types&&... _Args)
    {
        std::allocator<T> alloc;
        return std::allocate_shared<T>(alloc, std::forward<_Types>(_Args)...);
    }
 
    template<class T>
    using StdVector = std::vector<T>;
 
    template<class T>
    using StdBasicString = std::basic_string<T, std::char_traits<T>>;
 
    using StdString = StdBasicString<char>;
 
    template<class T>
    using StdBasicStringBuf = std::basic_stringbuf<T, std::char_traits<T>>;
 
    template<class T>
    using StdBasicIStringStream = std::basic_istringstream<T, std::char_traits<T>>;
 
    template<class T>
    using StdBasicOStringStream = std::basic_ostringstream<T, std::char_traits<T>>;
 
    template<class T>
    using StdBasicStringStream = std::basic_stringstream<T, std::char_traits<T>>;
 
    using StdStringBuf = StdBasicStringBuf<char>;
    using StdIStringStream = StdBasicIStringStream<char>;
    using StdOStringStream = StdBasicOStringStream<char>;
    using StdStringStream = StdBasicStringStream<char>;
 
    template <typename T>
    struct StdStringHash
    {
        std::size_t operator()(const T& obj) const noexcept
        {
            // Fallback implementation.
            auto hashfn = std::hash<T> {};
            return hashfn(obj);
        }
    };
 
    template <>
    struct StdStringHash<StdString>
    {
        std::size_t operator()(const StdString& s) const noexcept
        {
            return hash_bytes(s.data(), s.size());
        }
    };
 
    template<class T>
    using StdDeque = std::deque<T>;
 
    template<class T>
    using StdQueue = std::queue<T, StdDeque<T>>;
 
    template<class Key, class Value>
    using StdMap = std::map<Key, Value, std::less<Key>>;
 
    template<class Key, class Value>
    using StdUnorderedMap = std::unordered_map<Key, Value, StdStringHash<Key>, std::equal_to<Key>>;
 
    inline StdString to_string(int value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(long value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(long long value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(unsigned value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(unsigned long value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(unsigned long long value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(float value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(double value)
    {
        return std::to_string(value);
    }
    inline StdString to_string(long double value)
    {
        return std::to_string(value);
    }
#else
    template<class T>
    using StdUniquePtr = std::unique_ptr<T, Diarkis::DiarkisAllocatorDeleter<T>>;
 
    template <class T, class... _Types, typename std::enable_if<!std::is_array<T>::value, int>::type = 0>
    inline StdUniquePtr<T> DiarkisAllocUnique(_Types&&... _Args)
    {
        return std::move(StdUniquePtr<T>(DiarkisNew<T>(std::forward<_Types>(_Args)...)));
    }
 
    template <class T, typename std::enable_if<std::is_array<T>::value, int>::type = 0>
    inline StdUniquePtr<T> DiarkisAllocUnique(const size_t N)
    {
        return std::move(StdUniquePtr<T>(DiarkisNew<T>(N)));
    }
 
    template<class T, class... _Types>
    inline std::shared_ptr<T> DiarkisAllocShared(_Types&&... _Args)
    {
        DiarkisStdAllocator<T> alloc;
        return std::allocate_shared<T>(alloc, std::forward<_Types>(_Args)...);
    }
 
    template<class T>
    class StdVector : public std::vector<T, DiarkisStdAllocator<T>>
    {
    public:
        StdVector() : std::vector<T, DiarkisStdAllocator<T>>() {}
        StdVector(size_t count) : std::vector<T, DiarkisStdAllocator<T>>(count) {}
        StdVector(size_t count, const T& value) : std::vector<T, DiarkisStdAllocator<T>>(count, value) {}
        StdVector(std::initializer_list<T> ilist) : std::vector<T, DiarkisStdAllocator<T>>(ilist) {}
        template <class _Iter>
        StdVector(_Iter _First, _Iter _Last) : std::vector<T, DiarkisStdAllocator<T>>(_First, _Last) {}
        StdVector(const std::vector<T>& data) : std::vector<T, DiarkisStdAllocator<T>>(data.begin(), data.end()) {}
        StdVector(const StdVector<T>& data) : std::vector<T, DiarkisStdAllocator<T>>(data) {}
 
        inline StdVector& operator=(const std::vector<T>& data) 
        {
            std::vector<T, DiarkisStdAllocator<T>>::operator=(data);
            return *this;
        }
        inline StdVector& operator=(const StdVector&) = default;
        inline StdVector& operator=(StdVector&&) = default;
        inline operator std::vector<T>() const
        {
            return std::vector<T>(std::vector<T, DiarkisStdAllocator<T>>::cbegin(), std::vector<T, DiarkisStdAllocator<T>>::cend());
        }
 
    };
 
    class StdString : public std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>
    {
      public:
        StdString() : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>() {}
        StdString(const char *str) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(str) {}
        StdString(const std::string &s) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(s.begin(), s.end()) {}
        StdString(const char* str, size_t size) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(str, size) {}
        StdString(const StdString &s) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(s.begin(), s.end()) {}
        StdString(const std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>> str) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(str) {}
        StdString(size_t count, char ch) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(count, ch) {}
 
        template <class _Iter>
        StdString(_Iter _First, _Iter _Last) : std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>(_First, _Last) {}
 
        inline StdString& operator=(const char *str) 
        {
            std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>::operator=(str);
            return *this;
        }
        inline StdString& operator=(const std::string& s) 
        {
            std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>::operator=(s.c_str());
            return *this;
        }
        inline StdString& operator=(const StdString&) = default;
        inline StdString& operator=(StdString&&) = default;
 
        inline operator std::string() const
        {
            return std::string(std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>::cbegin(), std::basic_string<char, std::char_traits<char>, DiarkisStdAllocator<char>>::cend());
        }
    };
 
    inline StdString operator+ (const StdString& lhs, const StdString& rhs)
    {
        StdString result(lhs);
        result += rhs;
        return result;
    }
    inline StdString operator+ (const StdString& lhs, const char* rhs)
    {
        return operator+(lhs, StdString(rhs));
    }
    inline StdString operator+ (const char* lhs, const StdString& rhs)
    {
        return operator+(StdString(lhs), rhs);
    }
    inline StdString operator+ (const StdString& lhs, const char rhs)
    {
        return operator+(lhs, StdString(1, rhs));
    }
    inline StdString operator+ (const char lhs, const StdString& rhs)
    {
        return operator+(StdString(1, lhs), rhs);
    }
 
    template<class T>
    using StdBasicStringBuf = std::basic_stringbuf<T, std::char_traits<T>, DiarkisStdAllocator<T>>;
 
    template<class T>
    using StdBasicIStringStream = std::basic_istringstream<T, std::char_traits<T>, DiarkisStdAllocator<T>>;
 
    template<class T>
    using StdBasicOStringStream = std::basic_ostringstream<T, std::char_traits<T>, DiarkisStdAllocator<T>>;
 
    template<class T>
    using StdBasicStringStream = std::basic_stringstream<T, std::char_traits<T>, DiarkisStdAllocator<T>>;
 
    using StdStringBuf = StdBasicStringBuf<char>;
    using StdIStringStream = StdBasicIStringStream<char>;
    using StdOStringStream = StdBasicOStringStream<char>;
    using StdStringStream = StdBasicStringStream<char>;
 
    template <typename T>
    struct StdStringHash
    {
        std::size_t operator()(const T& obj) const noexcept
        {
            // Fallback implementation.
            auto hashfn = std::hash<T> {};
            return hashfn(obj);
        }
    };
 
    template <>
    struct StdStringHash<StdString>
    {
        std::size_t operator()(const StdString& s) const noexcept
        {
            return hash_bytes(s.data(), s.size());
        }
    };
 
    template<class T>
    using StdDeque = std::deque<T, Diarkis::DiarkisStdAllocator<T>>;
 
    template<class T>
    using StdQueue = std::queue<T, StdDeque<T>>;
 
    template<class Key, class Value>
    using StdMap = std::map<Key, Value, std::less<Key>, Diarkis::DiarkisStdAllocator<std::pair<const Key, Value>>>;
 
    template<class Key, class Value>
    using StdUnorderedMap = std::unordered_map<Key, Value, StdStringHash<Key>, std::equal_to<Key>, Diarkis::DiarkisStdAllocator<std::pair<const Key, Value>>>;
 
    inline StdString to_string(int value)
    {
        char buf[sizeof(int) * 4];
        snprintf(buf, sizeof(buf), "%d", value);
        return StdString(buf);
    }
    inline StdString to_string(long value)
    {
        char buf[sizeof(long) * 4];
        snprintf(buf, sizeof(buf), "%ld", value);
        return StdString(buf);
    }
    inline StdString to_string(long long value)
    {
        char buf[sizeof(long long) * 4];
        snprintf(buf, sizeof(buf), "%lld", value);
        return StdString(buf);
    }
    inline StdString to_string(unsigned value)
    {
        char buf[sizeof(unsigned) * 4];
        snprintf(buf, sizeof(buf), "%u", value);
        return StdString(buf);
    }
    inline StdString to_string(unsigned long value)
    {
        char buf[sizeof(unsigned long) * 4];
        snprintf(buf, sizeof(buf), "%lu", value);
        return StdString(buf);
    }
    inline StdString to_string(unsigned long long value)
    {
        char buf[sizeof(unsigned long long) * 4];
        snprintf(buf, sizeof(buf), "%llu", value);
        return StdString(buf);
    }
    inline StdString to_string(float value)
    {
        char buf[sizeof(float) * 4];
        snprintf(buf, sizeof(buf), "%f", value);
        return StdString(buf);
    }
    inline StdString to_string(double value)
    {
        char buf[sizeof(double) * 4];
        snprintf(buf, sizeof(buf), "%f", value);
        return StdString(buf);
    }
    inline StdString to_string(long double value)
    {
        char buf[sizeof(long double) * 4];
        snprintf(buf, sizeof(buf), "%Lf", value);
        return StdString(buf);
    }
#endif  // ENABLE_CUSTOM_ALLOCATOR
 
    bool DIARKIS_EXPORT ParseErrStruct(uint8_t status, const Diarkis::StdVector<uint8_t>& payload, uint16_t& errCode, Diarkis::StdString& errString);
}
// ADD NAMESPACE } TAG
 
#ifndef DIARKIS_DISABLE_CUSTOM_ALLOCATOR_FOR_STD_LIBS
namespace std
{
    template <>
    class hash<Diarkis::StdString>
    {
    public:
        size_t operator()(const Diarkis::StdString& str) const
        {
            return hash_bytes(str.data(), str.length());;
        }
    };
}
#endif