WrappedSystem.hpp

Go to the documentation of this file.

#pragma once
 
#include "BaseFunction.hpp"
#include "Demangle.hpp"
 
namespace Engine {
class Core;

template <typename TSystem, typename TErrorCallback>
class WrappedSystem : public FunctionUtils::BaseFunction<void, Core &> {
  public:
    explicit WrappedSystem(TSystem system, TErrorCallback errorCallback)
        : _system(system), _errorCallback(errorCallback)
    {
        _id = GetCallableID(_system);
        _name = GetCallableName(_system);
    }

    ~WrappedSystem() override = default;

    void operator()(Engine::Core &core) const override
    {
        try
        {
            return _system(core);
        }
        catch (const std::exception &) // NOSONAR
        {
            _errorCallback(core);
            throw;
        }
    }

    FunctionUtils::FunctionID GetID() const override { return _id; }

    std::string GetName() const override { return _name; }

    static FunctionUtils::FunctionID GetCallableID(const TSystem &callable)
    {
        if constexpr (std::is_class_v<TSystem>)
        {
            return typeid(callable).hash_code();
        }
        else
        {
            return std::hash<TSystem>{}(callable);
        }
    }

    static std::string GetCallableName(const TSystem &callable)
    {
        if constexpr (std::is_class_v<TSystem>)
        {
            return FunctionUtils::DemangleTypeName(typeid(callable));
        }
        else
        {
            return std::to_string(GetCallableID(callable));
        }
    }
 
  private:
    [[no_unique_address]] TSystem _system;

    [[no_unique_address]] TErrorCallback _errorCallback;

    FunctionUtils::FunctionID _id = 0;

    std::string _name;
};
} // namespace Engine