Util.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "Exception.h"
 
namespace Util
{
    class INonCopyable
    {
    protected:
        constexpr INonCopyable() = default;
        ~INonCopyable() = default;
 
    public:
        INonCopyable(const INonCopyable&) = delete;
        INonCopyable& operator=(const INonCopyable&) = delete;
    };
 
    class INonMovable
    {
    protected:
        constexpr INonMovable() = default;
        ~INonMovable() = default;
 
    public:
        INonMovable(const INonMovable&) = default;
        INonMovable& operator=(const INonMovable&) = default;
 
        INonMovable(INonMovable&&) = delete;
        INonMovable& operator=(INonMovable&&) = delete;
    };
 
    class ILockable : public INonCopyable
    {
    public:
        static constexpr std::chrono::milliseconds DefaultTimeout = std::chrono::milliseconds(10);
 
    protected:
        using MutexType = std::timed_mutex;
        using LockType = std::unique_lock<MutexType>;
 
        ILockable() = default;
        ~ILockable() = default;
 
        [[nodiscard]] LockType AcquireLock(const std::chrono::milliseconds Timeout = DefaultTimeout) const;
 
    private:
        mutable MutexType LockMutex;    
    };
 
    class TimeoutException;
    template <typename> class SynchronizedPointer;
 
    class ISynchronizedPointerLockable : public INonCopyable
    {
        // Every SynchronizedPointer<...> should be friend to allow SynchronizedPointers to derived classes
        template <typename>
        friend class SynchronizedPointer;
 
    protected:
        ISynchronizedPointerLockable() : OwnedCount(0) {}
        ~ISynchronizedPointerLockable() { assert(!OwnedCount); }    
 
    private:
        void AcquireLock(const std::chrono::milliseconds Timeout) const
        {
            using namespace std::chrono_literals;
 
            // In order to compensate for spurious failures by retrying
            // (see https://en.cppreference.com/w/cpp/thread/timed_mutex/try_lock_for)
            constexpr int NumTries = 2;
 
            if (OwnerID != std::this_thread::get_id())
            {
                if (Timeout == 0ms)
                    LockMutex.lock();
                else
                {
                    bool Success = false;
                    auto TimeoutPerTry = Timeout / NumTries;
                    for (auto i = NumTries; i > 0 && !Success; --i)
                        Success = LockMutex.try_lock_for(TimeoutPerTry);
 
                    if (!Success)
                        throw TimeoutException("Timeout occurred while trying to lock a mutex.");
                }
 
                OwnerID = std::this_thread::get_id();
            }
 
            ++OwnedCount;
        }
 
        void ReleaseLock() const
        {
            if (!OwnedCount || OwnerID != std::this_thread::get_id())
                return;
            
            --OwnedCount;
            if (!OwnedCount)
            {
                OwnerID = std::thread::id();
                LockMutex.unlock();
            }
        }
 
        mutable std::timed_mutex LockMutex;                 
        mutable std::atomic<std::thread::id> OwnerID;       
        mutable std::atomic<size_t> OwnedCount;             
    };
 
    template <typename T>
    class SynchronizedPointer : public INonCopyable
    {
        template <typename>
        friend class SynchronizedPointer;
 
    public:
        SynchronizedPointer() noexcept : LockableObject(nullptr) {}
 
        SynchronizedPointer(T* const LockableObject,
            const std::chrono::milliseconds Timeout = ILockable::DefaultTimeout)
            : LockableObject(LockableObject) { if (LockableObject) LockableObject->AcquireLock(Timeout); }
 
        SynchronizedPointer(SynchronizedPointer&& Other) noexcept : LockableObject(Other.LockableObject) { Other.LockableObject = nullptr; }
 
        SynchronizedPointer& operator=(SynchronizedPointer&& Other) noexcept
        {
            LockableObject = Other.LockableObject;
            Other.LockableObject = nullptr;
 
            return *this;
        }
 
        template <typename U>
        explicit SynchronizedPointer(SynchronizedPointer<U>&& Other)
        {
            if (!Other.LockableObject)
                LockableObject = nullptr;
            else
            {
                LockableObject = dynamic_cast<T*>(Other.LockableObject);
                if (!LockableObject)
                    throw Util::TypeErrorException();
 
                Other.LockableObject = nullptr;
            }
        }
 
        ~SynchronizedPointer() { if (LockableObject) LockableObject->ReleaseLock(); }
 
        auto get() const noexcept { return LockableObject; }
 
        bool operator==(const T* rhs) const noexcept { return LockableObject == rhs; }
        bool operator!=(const T* rhs) const noexcept { return LockableObject != rhs; }
        bool operator==(const SynchronizedPointer& rhs) const noexcept { return LockableObject == rhs.get(); }
        bool operator!=(const SynchronizedPointer& rhs) const noexcept { return LockableObject != rhs.get(); }
        explicit operator bool() const noexcept { return LockableObject != nullptr; }
 
        auto operator->() const noexcept { return LockableObject; }
        auto& operator*() const noexcept { return *LockableObject; }
 
    private:
        T* LockableObject;
    };
 
    class OneToOneNotifier : public INonCopyable
    {
    public:
        OneToOneNotifier() : EventOccurred(false), SomeoneIsWaiting(false), MutexCanBeDestroyed(true) {}
        ~OneToOneNotifier();
 
        bool Wait(const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
 
        void Notify();  
        void Ignore();  
 
    private:
        bool EventOccurred;
        bool SomeoneIsWaiting;
        std::atomic<bool> MutexCanBeDestroyed;
 
        std::mutex Mutex;
        std::condition_variable ConditionVariable;
    };
 
    template <typename T, typename... ListTs>
    struct is_contained_in : std::disjunction<std::is_same<T, ListTs>...> {};
 
    template <typename T, typename... ListTs>
    inline constexpr bool is_contained_in_v = is_contained_in<T, ListTs...>::value;
 
    template <typename CallableT>
    struct member_fn_ptr_traits;
 
    template <typename ReturnT, typename ObjectT, typename... ArgumentTs>
    struct member_fn_ptr_traits<ReturnT (ObjectT::*)(ArgumentTs...) const>
    {
        using return_type = ReturnT;
        using instance_type = ObjectT;
        using argument_types = std::tuple<ArgumentTs...>;
    };
 
    template <typename ReturnT, typename ObjectT, typename... ArgumentTs>
    struct member_fn_ptr_traits<ReturnT(ObjectT::*)(ArgumentTs...) noexcept>
    {
        using return_type = ReturnT;
        using instance_type = ObjectT;
        using argument_types = std::tuple<ArgumentTs...>;
    };
 
    template <typename ReturnT, typename ObjectT, typename... ArgumentTs>
    struct member_fn_ptr_traits<ReturnT(ObjectT::*)(ArgumentTs...) const noexcept>
    {
        using return_type = ReturnT;
        using instance_type = ObjectT;
        using argument_types = std::tuple<ArgumentTs...>;
    };
 
    template <typename ReturnT, typename ObjectT, typename... ArgumentTs>
    struct member_fn_ptr_traits<ReturnT (ObjectT::*)(ArgumentTs...)>
    {
        using return_type = ReturnT;
        using instance_type = ObjectT;
        using argument_types = std::tuple<ArgumentTs...>;
    };
 
    template <typename CallableT>
    using return_of_t = typename member_fn_ptr_traits<CallableT>::return_type;
 
    template <typename CallableT>
    using instance_of_t = typename member_fn_ptr_traits<CallableT>::instance_type;
 
    template <typename CallableT>
    using argument_of_t = typename member_fn_ptr_traits<CallableT>::argument_types;
 
    template <typename TupleT>
    struct remove_first_from_tuple;
 
    template <typename FirstElementT, typename... ElementTs>
    struct remove_first_from_tuple<std::tuple<FirstElementT, ElementTs...>> { using type = std::tuple<ElementTs...>; };
 
    template <typename TupleT>
    using remove_first_from_tuple_t = typename remove_first_from_tuple<TupleT>::type;
 
    // Index sequence manipulation to define a starting point 
 
    template <size_t Offset, typename IndexSequence>
    struct OffsetIndexSequence;
 
    template <size_t Offset, size_t... Indices>
    struct OffsetIndexSequence<Offset, std::index_sequence<Indices...>>
    {
        using type = std::index_sequence<Indices + Offset...>;
    };
 
    template <size_t Offset, typename IndexSequence>
    using OffsetIndexSequence_t = typename OffsetIndexSequence<Offset, IndexSequence>::type;
 
    template <size_t From, size_t To>
    struct RangeIndexSequence
    {
        using type = OffsetIndexSequence_t<From, std::make_index_sequence<To - From>>;
    };
 
    template <size_t From, size_t To>
    using RangeIndexSequence_t = typename RangeIndexSequence<From, To>::type;
 
    template <typename ObjectT, typename CallableT>
    class CallableMemberWrapper : public INonMovable
    {
        using ArgumentTs = argument_of_t<CallableT>;
 
    public:
        constexpr CallableMemberWrapper(ObjectT& Object, const CallableT Callable, ArgumentTs DefaultArgs = {}) noexcept
            : Object(Object), Callable(Callable), DefaultArgs(std::move(DefaultArgs)) {}
 
        template <typename... ArgTs>
        auto operator()(ArgTs&& ...Args) const
        {
            return Invoke(RangeIndexSequence_t<sizeof...(ArgTs), std::tuple_size_v<ArgumentTs>>(), std::forward<ArgTs>(Args)...);
        }
 
    private:
        template <size_t... Indices, typename... ArgTs>
        auto Invoke(std::integer_sequence<size_t, Indices...>, ArgTs&& ...Args) const
        {
            return (Object.*Callable)(std::forward<ArgTs>(Args)..., std::get<Indices>(DefaultArgs)...);
        }
 
        ObjectT& Object;                
        const CallableT Callable;       
        const ArgumentTs DefaultArgs;   
    };
 
    template <typename ObjectT, typename CallableT>
    class OnDestruction
    {
    public:
        template <typename... ArgTs>
        OnDestruction(ObjectT& Object, const CallableT Callable, ArgTs&& ...Args)
            : CallableWrapper(Object, std::move(Callable), { std::forward<ArgTs>(Args)... }) {}
 
        ~OnDestruction() { CallableWrapper(); }
 
    private:
        CallableMemberWrapper<ObjectT, CallableT> CallableWrapper;
    };
 
    class BlobDataType
    {
    public:
        using DataType = unsigned char[];                       
 
    private:
        using DataPtrType = std::unique_ptr<DataType>;          
 
    public:
        BlobDataType() = default;                               
        BlobDataType(const BlobDataType& Other);                
        BlobDataType(BlobDataType&& Other) noexcept;            
 
        BlobDataType& operator=(const BlobDataType& Other);     
        BlobDataType& operator=(BlobDataType&& Other) noexcept; 
 
        void Reserve(size_t Size);                              
        void Assign(size_t Size, const DataType Data);          
        void Reset();                                           
        DataPtrType::element_type* Release() noexcept;          
        auto GetPtr() noexcept { return DataPtr.get(); }        
        auto Size() const noexcept { return DataSize; }         
 
    private:
        DataPtrType DataPtr;                                    
        size_t DataSize = 0;                                    
    };
 
    class OptionalBool
    {
    public:
        enum class Values { Unknown, False, True };
 
        constexpr OptionalBool() noexcept : Value(Values::Unknown) {}                                                   
        constexpr OptionalBool(Values Value) noexcept : Value(Value) {}                                                 
        constexpr OptionalBool(bool b) noexcept : Value(b ? Values::True : Values::False) {}                            
        constexpr OptionalBool(const OptionalBool& Other) noexcept : Value(Other.Value) {}                              
 
        constexpr OptionalBool& operator=(Values Value) noexcept { this->Value = Value; return *this; }                 
        constexpr OptionalBool& operator=(bool b) noexcept { Value = b ? Values::True : Values::False; return *this; }  
        constexpr OptionalBool& operator=(OptionalBool& Other) noexcept { Value = Other.Value; return *this; }          
 
        constexpr bool operator==(Values Value) const noexcept { return this->Value == Value; }                         
        constexpr bool operator!=(Values Value) const noexcept { return this->Value != Value; }                         
 
        constexpr operator bool() const noexcept { return Value == Values::True; }                                      
        constexpr Values Get() const noexcept { return Value; }                                                         
 
    private:
        Values Value;                                                                                                   
    };
 
    class UniqueID
    {
    public:
        template <typename T>
        static size_t Get() noexcept
        {
            static const size_t ID = Make();
 
            return ID;
        }
 
    private:
        static size_t Make() noexcept;
    };
 
    template <typename T>
    inline void HashCombine(std::size_t& seed, const T& value)
    {
        std::hash<T> hasher;
        seed ^= hasher(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }
 
    using seconds = std::chrono::duration<double>;                  
    using picoseconds = std::chrono::duration<double, std::pico>;   
 
    static constexpr double SpeedOfLight = (GSL_CONST_MKSA_SPEED_OF_LIGHT);
 
    constexpr auto ConvertFrequencyWavelength(double Value) noexcept { return SpeedOfLight / Value; }
 
 
    template <typename T>
    std::ostream& operator<<(std::ostream& stream, const std::chrono::time_point<T>& TimePoint)
    {
        const auto ZonedTime = std::chrono::zoned_time(std::chrono::current_zone(), std::chrono::round<std::chrono::seconds>(TimePoint));
        stream << std::format("{:%T %d.%m.%Y}", ZonedTime);
 
        return stream;
    }
 
    template <typename T>
    T StrToT(const std::string& String)
    {
        std::stringstream ss(String);
        T Value;
        ss >> Value;
 
        if (ss.fail())
            throw InvalidDataException("String cannot be converted to " + std::string(typeid(T).name()) + ".");
 
        return Value;
    }
 
    template <typename T>
    std::string ToStr(const T& Value, int Precision = -1)
    {
        std::stringstream ss;
 
        if (Precision >= 0)
            ss << std::fixed << std::setprecision(Precision);
 
        ss << Value;
        return ss.str();
    }
 
    template <typename T>
    std::string ToStr(const std::chrono::time_point<T>& TimePoint)
    {
        std::stringstream ss;
        
        Util::operator<<(ss, TimePoint);
        return ss.str();
    }
 
    inline std::string ToStr(const char Value) { return ToStr(static_cast<int>(Value)); }
 
    inline std::string ToStr(const uint8_t Value) { return ToStr(static_cast<int>(Value)); }
 
    inline std::string ToStr(const QString& Str) { return Str.toStdString(); }
 
    template <typename ToT, typename FromT, std::enable_if_t<
        std::is_integral_v<ToT> && std::is_integral_v<FromT> &&
        std::is_same_v<std::remove_cv_t<ToT>, std::remove_cv_t<FromT>>, int> = 0
    >
    inline ToT NumToT(const FromT Value)
    {
        return Value;
    }
 
    template <typename ToT, typename FromT, std::enable_if_t<
        std::is_integral_v<ToT> && std::is_integral_v<FromT> &&
        !std::is_same_v<std::remove_cv_t<ToT>, std::remove_cv_t<FromT>> &&
        ((std::is_signed_v<ToT> && std::is_signed_v<FromT>) || (std::is_unsigned_v<ToT> && std::is_unsigned_v<FromT>)), int> = 0
    >
    ToT NumToT(const FromT Value)
    {
        if (Value < std::numeric_limits<ToT>::lowest() || Value > std::numeric_limits<ToT>::max())
            throw OutOfRangeException("Cannot convert Value into destiny type since this would cause an underflow or an overflow.");
 
        return static_cast<ToT>(Value);
    }
 
    template <typename ToT, typename FromT, std::enable_if_t<
        std::is_integral_v<ToT> && std::is_integral_v<FromT> &&
        !std::is_same_v<std::remove_cv_t<ToT>, std::remove_cv_t<FromT>> &&
        std::is_signed_v<ToT> && std::is_unsigned_v<FromT>, int> = 0
    >
    ToT NumToT(const FromT Value)
    {
        if (Value > static_cast<std::make_unsigned_t<ToT>>(std::numeric_limits<ToT>::max()))
            throw OverflowException("Cannot convert Value into destiny type since this would cause an overflow.");
 
        return static_cast<ToT>(Value);
    }
 
    template <typename ToT, typename FromT, std::enable_if_t<
        std::is_integral_v<ToT> && std::is_integral_v<FromT> &&
        !std::is_same_v<std::remove_cv_t<ToT>, std::remove_cv_t<FromT>> &&
        std::is_unsigned_v<ToT> && std::is_signed_v<FromT>, int> = 0
    >
    ToT NumToT(const FromT Value)
    {
        if (Value < 0)
            throw UnderflowException("Cannot convert Value into destiny type since this would cause an underflow.");
        if (static_cast<std::make_unsigned_t<FromT>>(Value) > std::numeric_limits<ToT>::max())
            throw OverflowException("Cannot convert Value into destiny type since this would cause an overflow.");
 
        return static_cast<ToT>(Value);
    }
 
    template <typename ToT, std::enable_if_t<
        std::is_integral_v<ToT> &&
        !std::is_same_v<std::remove_cv_t<ToT>, double>, int> = 0
    >
    ToT NumToT(const double Value)
    {
        const double RoundedValue = std::round(Value);
 
        if (RoundedValue < static_cast<double>(std::numeric_limits<ToT>::lowest()))
            throw UnderflowException("Cannot convert Value into double since this would cause an underflow.");
        if (RoundedValue > static_cast<double>(std::numeric_limits<ToT>::max()))
            throw OverflowException("Cannot convert Value into double since this would cause an overflow.");
 
        return static_cast<ToT>(RoundedValue);
    }
 
    template <typename T>
    inline std::string ToUnitStr();
 
    template <>
    inline std::string ToUnitStr<std::chrono::seconds>()
    {
        return "s";
    }
 
    template <>
    inline std::string ToUnitStr<std::chrono::milliseconds>()
    {
        return "ms";
    }
 
    template <>
    inline std::string ToUnitStr<std::chrono::microseconds>()
    {
        return "us";
    }
 
    template <>
    inline std::string ToUnitStr<std::chrono::nanoseconds>()
    {
        return "ns";
    }
 
    template <>
    inline std::string ToUnitStr<seconds>()
    {
        return "s";
    }
 
    template <>
    inline std::string ToUnitStr<picoseconds>()
    {
        return "ps";
    }
 
    inline std::string TrimTrailingZeros(const std::string& Str) { return Str.substr(0, Str.find('\0')); }
 
    inline auto CurrentTimeAndDateString() { return ToStr(std::chrono::system_clock::now()); }
 
    inline auto FilenameFromPath(std::string Path) { return Path.substr(Path.find_last_of("\\") + 1, Path.length() - Path.find_last_of("\\") - 1); }
 
    inline auto RemoveExtFromPath(std::string Path) { return Path.substr(0,  Path.find_last_of(".")); }
 
    struct VersionType
    {
        unsigned int Major{};
        unsigned int Minor{};
        unsigned int Patch{};
    };
 
    std::strong_ordering operator<=>(const VersionType& lhs, const VersionType& rhs);
 
    VersionType VersionFromString(std::string_view Str);
 
    inline std::string ToStr(const VersionType& Version) { return ToStr(Version.Major) + "." + ToStr(Version.Minor) + "." + ToStr(Version.Patch); }
 
    template <typename... Ts>
    std::vector<std::tuple<Ts...>> ParseCSV(const std::string& CSVData, const char Delimiter = ';', const size_t SkipLines = 0)
    {
        std::vector<std::tuple<Ts...>> ParsedLines;
        std::istringstream CSVDataStream(CSVData);
 
        // Ignore header lines
        for (auto i = SkipLines; i > 0; --i)
            CSVDataStream.ignore(std::numeric_limits<std::streamsize>::max(), CSVDataStream.widen('\n'));
 
        // Function to parse one field from a single line
        const auto GetValue = [Delimiter]<typename T>(std::istringstream& LineStream) {
            std::string ValueStr;
            std::getline(LineStream, ValueStr, Delimiter);
            std::istringstream ValueStream(ValueStr);
            ValueStream.exceptions(std::istringstream::failbit | std::istringstream::badbit);
 
            T Value;
            ValueStream >> Value;
 
            return Value;
        };
 
        // Loop through each line and fill ParsedLines with tuples of column data.
        std::string Line;
        while (std::getline(CSVDataStream, Line))
        {
            std::istringstream LineStream(Line);
            LineStream.exceptions(std::istringstream::failbit | std::istringstream::badbit);
 
            // Braced initialization to ensure correct evaluation order (left to right). Refer to
            // https://stackoverflow.com/questions/14056000/how-to-avoid-undefined-execution-order-for-the-constructors-when-using-stdmake
            ParsedLines.push_back({ GetValue.template operator()<Ts>(LineStream)... });
        }
 
        return ParsedLines;
    }
 
    std::string ExceptionToStr(const std::exception_ptr ExceptionPtr);
 
    std::string ToLower(std::string_view Str);
 
    std::vector<std::complex<double>> FFT(const std::vector<std::complex<double>>& Data, bool InverseTransform = false);
 
    class Warning : public ILockable
    {
    public:
        struct WarningData
        {
            WarningData() : ErrorCode(DynExpErrorCodes::NoError), Line(0) {}
 
            WarningData(std::string Description, const int ErrorCode = DynExpErrorCodes::GeneralError,
                const std::source_location Location = std::source_location::current())
                : Description(std::move(Description)), ErrorCode(ErrorCode),
                Line(Location.line()), Function(Location.function_name()), File(Location.file_name()) {}
            WarningData(std::string Description, const int ErrorCode = DynExpErrorCodes::GeneralError,
                const size_t Line = 0, std::string Function = "", std::string File = "")
                : Description(std::move(Description)), ErrorCode(ErrorCode),
                Line(Line), Function(std::move(Function)), File(std::move(File)) {}
 
            explicit operator bool() const noexcept { return ErrorCode != DynExpErrorCodes::NoError; }
 
            const std::string Description;  
            const int ErrorCode;            
            const size_t Line;              
            const std::string Function;     
            const std::string File;         
        };
 
        Warning() : Data(std::make_unique<WarningData>()) {}
 
        Warning(std::string Description, const int ErrorCode = DynExpErrorCodes::GeneralError,
            const std::source_location Location = std::source_location::current())
            : Data(std::make_unique<WarningData>(std::move(Description), ErrorCode, Location)) {}
 
        Warning(const Exception& e)
            : Data(std::make_unique<WarningData>(e.what(), e.ErrorCode, e.Line, e.Function, e.File)) {}
 
        Warning(Warning&& Other) noexcept;
 
        virtual ~Warning() = default;
 
        void Reset();                                   
 
        Warning& operator=(const Exception& e);         
        Warning& operator=(Warning&& Other) noexcept;   
 
        WarningData Get() const;                        
 
    private:
        std::unique_ptr<WarningData> Data;
    };
 
    struct LogEntry
    {
        LogEntry(std::string Message, ErrorType Type, std::chrono::system_clock::time_point TimePoint)
            : Message(std::move(Message)), Type(Type), TimePoint(TimePoint) {}
 
        const std::string Message;                              
        const ErrorType Type;                                   
        const std::chrono::system_clock::time_point TimePoint;  
    };
 
    class EventLogger : public ILockable
    {
        friend EventLogger& EventLog();
 
        EventLogger();
 
        EventLogger(std::string Filename) : EventLogger() { OpenLogFile(Filename); }
 
    public:
        ~EventLogger() { CloseLogFileUnsafe(); }
 
 
        void Log(const std::string& Message, const ErrorType Type = ErrorType::Info,
            const size_t Line = 0, const std::string& Function = "", const std::string& File = "", const int ErrorCode = 0
#ifdef DYNEXP_HAS_STACKTRACE
            , const std::stacktrace& Trace = {}
#endif // DYNEXP_HAS_STACKTRACE
        ) noexcept;
 
        void Log(const Exception& E) noexcept;
 
        void Log(const Warning& W) noexcept;
 
        static std::string FormatLog(const std::string& Message, const size_t Line = 0,
            const std::string& Function = "", const std::string& Filename = "", const int ErrorCode = 0, const bool PrefixMessage = true);
        
        static std::string FormatLogHTML(const std::string& Message, const ErrorType Type = ErrorType::Info,
            const size_t Line = 0, const std::string& Function = "", const std::string& Filename = "", const int ErrorCode = 0
#ifdef DYNEXP_HAS_STACKTRACE
            , const std::stacktrace& Trace = {}
#endif // DYNEXP_HAS_STACKTRACE
        );
 
        void OpenLogFile(std::string Filename);
 
        void CloseLogFile() { auto lock = AcquireLock(LogOperationTimeout); CloseLogFileUnsafe(); }
 
        bool IsOpen() const { auto lock = AcquireLock(LogOperationTimeout); return IsOpenUnsafe(); }
 
        std::string GetLogFilename() const { auto lock = AcquireLock(LogOperationTimeout); return Filename; }
 
        void ClearLog() { auto lock = AcquireLock(LogOperationTimeout); ClearLogUnsafe(); }
 
        std::vector<LogEntry> GetLog(size_t FirstElement = 0) const;
 
        auto GetLogSize() const { auto lock = AcquireLock(LogOperationTimeout); return LogEntries.size(); }
 
    private:
        bool IsOpenUnsafe() const { return LogFile.is_open(); }
        void CloseLogFileUnsafe();
        void ClearLogUnsafe() { LogEntries.clear(); }
 
        static constexpr auto LogOperationTimeout = std::chrono::milliseconds(100);
 
        std::ofstream LogFile;              
        std::string Filename;               
 
        std::vector<LogEntry> LogEntries;   
    };
 
    EventLogger& EventLog();
 
    template <typename EnumType, std::enable_if_t<
        std::is_enum_v<EnumType>, int> = 0
    >
    class FeatureTester
    {
    public:
        constexpr FeatureTester() noexcept = default;
 
        template <size_t N>
        FeatureTester(const std::array<EnumType, N>& Flags)
        {
            for (const auto Flag : Flags)
                Set(Flag);
        }
 
        template <size_t N>
        bool Test(const std::array<EnumType, N>& Flags) const
        {
            for (const auto Flag : Flags)
            {
                auto Result = Features.test(static_cast<size_t>(Flag));
 
                if (!Result)
                    false;
            }
 
            return true;
        }
 
        bool Test(EnumType Flag) const { return Features.test(static_cast<size_t>(Flag)); }
 
        void Set(EnumType Flag) { Features.set(static_cast<size_t>(Flag)); }
 
    private:
        std::bitset<static_cast<size_t>(EnumType::NUM_ELEMENTS)> Features;
    };
 
    template <
        typename CallableT,
        std::enable_if_t<std::is_enum_v<return_of_t<CallableT>>, int> = 0
    >
    class StateMachineState
    {
    public:
        using StateEnumType = return_of_t<CallableT>;
        using CallableType = CallableT;
 
        constexpr StateMachineState(StateEnumType State, CallableT StateFunction, const char* Description = "", const bool IsFinal = false) noexcept
            : State(State), StateFunction(StateFunction), Description(Description), Final(IsFinal)
        {}
 
        constexpr StateEnumType GetState() const noexcept { return State; }     
        constexpr auto GetDescription() const noexcept { return Description; }  
        constexpr bool IsFinal() const noexcept { return Final; }               
 
        template <typename... ArgTs>
        StateEnumType Invoke(instance_of_t<CallableT>& Instance, ArgTs&&... Args) const
        {
            return (Instance.*StateFunction)(std::forward<ArgTs>(Args)...);
        }
        
    private:
        const StateEnumType State;
        const std::decay_t<CallableT> StateFunction;
        const char* Description;
 
        const bool Final;
    };
 
    template <typename StateMachineStateT>
    class StateMachineContext
    {
    public:
        using StateType = StateMachineStateT;
        using StateEnumType = typename StateType::StateEnumType;                        
        using ReplacementListType = std::unordered_map<StateEnumType, StateEnumType>;
 
        StateMachineContext() = default;
 
        StateMachineContext(ReplacementListType&& ReplacementList, const char* Description = "",
            std::initializer_list<const StateMachineContext*> BaseContexts = {})
            : ReplacementList(std::move(ReplacementList)), Description(Description)
        {
            for (auto BaseContext : BaseContexts)
                if (BaseContext)
                    this->ReplacementList.insert(BaseContext->ReplacementList.cbegin(), BaseContext->ReplacementList.cend());
        }
 
        constexpr auto GetDescription() const noexcept { return Description; }
 
        StateEnumType AdaptState(StateEnumType State) const
        {
            auto AdaptedState = ReplacementList.find(State);
 
            return AdaptedState == ReplacementList.cend() ? State : AdaptedState->second;
        }
 
    private:
        ReplacementListType ReplacementList;
 
        const char* Description;
    };
 
    template <typename StateMachineStateT>
    class StateMachine
    {
    public:
        using StateType = StateMachineStateT;
        using StateEnumType = typename StateType::StateEnumType;                    
        using ContextType = StateMachineContext<StateMachineStateT>;
 
        template <typename... StateMachineStateTs>
        StateMachine(const StateType& InitialState, const StateMachineStateTs&... States)
            : StatesList{ { InitialState.GetState(), &InitialState }, { States.GetState(), &States }... },
            CurrentState(&InitialState), CurrentContext(nullptr)
        {}
 
        const StateType* GetCurrentState() const noexcept { return CurrentState; }  
        const ContextType* GetContext() const noexcept { return CurrentContext; }   
 
        void SetCurrentState(StateEnumType NewState)
        {
            if (CurrentContext)
                CurrentState = StatesList.at(CurrentContext.load()->AdaptState(NewState));
            else
                CurrentState = StatesList.at(NewState);
        }
 
        void SetContext(const ContextType* NewContext) { CurrentContext = NewContext; }
 
        void ResetContext() { CurrentContext = nullptr; }
 
        template <typename... ArgTs>
        void Invoke(instance_of_t<typename StateType::CallableType>& Instance, ArgTs&&... Args)
        {
            if (!CurrentState)
                throw InvalidStateException("CurrentState must not be nullptr in order to be invoked.");
 
            if (CurrentState.load()->IsFinal())
                CurrentState.load()->Invoke(Instance, std::forward<ArgTs>(Args)...);
            else
                SetCurrentState(CurrentState.load()->Invoke(Instance, std::forward<ArgTs>(Args)...));
        }
 
    private:
        const std::unordered_map<StateEnumType, const StateType*> StatesList;
 
        std::atomic<const StateType*> CurrentState;
        std::atomic<const ContextType*> CurrentContext;
    };
}