InterModuleCommunicator.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "DynExpCore.h"
 
namespace DynExpInstr
{
    class InterModuleCommunicator;
 
    namespace InterModuleCommunicatorTasks
    {
        class InitTask : public DynExp::InitTaskBase
        {
            void InitFuncImpl(dispatch_tag<DynExp::InitTaskBase>, DynExp::InstrumentInstance& Instance) override final;
 
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}  
        };
 
        class ExitTask : public DynExp::ExitTaskBase
        {
            void ExitFuncImpl(dispatch_tag<DynExp::ExitTaskBase>, DynExp::InstrumentInstance& Instance) override final;
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DynExp::UpdateTaskBase
        {
            void UpdateFuncImpl(dispatch_tag<DynExp::UpdateTaskBase>, DynExp::InstrumentInstance& Instance) override final;
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class InterModuleCommunicatorData : public DynExp::InstrumentDataBase
    {
    public:
        InterModuleCommunicatorData() = default;
        virtual ~InterModuleCommunicatorData() = default;
 
    private:
        void ResetImpl(dispatch_tag<DynExp::InstrumentDataBase>) override final;
        virtual void ResetImpl(dispatch_tag<InterModuleCommunicatorData>) {};               
    };
 
    class InterModuleCommunicatorParams : public DynExp::InstrumentParamsBase
    {
    public:
        InterModuleCommunicatorParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : DynExp::InstrumentParamsBase(ID, Core) {}
 
        virtual ~InterModuleCommunicatorParams() = default;
 
        virtual const char* GetParamClassTag() const noexcept override { return "InterModuleCommunicatorParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<DynExp::InstrumentParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<InterModuleCommunicatorParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<InterModuleCommunicatorParams>) {}    
 
        DummyParam Dummy = { *this };                                                       
    };
 
    class InterModuleCommunicatorConfigurator : public DynExp::InstrumentConfiguratorBase
    {
    public:
        using ObjectType = InterModuleCommunicator;
        using ParamsType = InterModuleCommunicatorParams;
 
        InterModuleCommunicatorConfigurator() = default;
        virtual ~InterModuleCommunicatorConfigurator() = default;
 
    private:
        virtual DynExp::ParamsBasePtrType MakeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) const override { return DynExp::MakeParams<InterModuleCommunicatorConfigurator>(ID, Core); }
    };
 
    class InterModuleCommunicator : public DynExp::InstrumentBase
    {
    public:
        using ParamsType = InterModuleCommunicatorParams;                               
        using ConfigType = InterModuleCommunicatorConfigurator;                         
        using InstrumentDataType = InterModuleCommunicatorData;                         
 
        constexpr static auto Name() noexcept { return "Inter-Module Communicator"; }   
 
        InterModuleCommunicator(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params);
 
        virtual ~InterModuleCommunicator() {}
 
        virtual std::string GetName() const override { return Name(); }
 
        template <typename DerivedEvent,
            std::enable_if_t<std::is_base_of_v<DynExp::InterModuleEventBase, DerivedEvent>, int> = 0>
        void PostEvent(const DynExp::ModuleBase& Caller, const DerivedEvent& InterModuleEvent) const
        {
            auto& ModuleMgr = Core.GetModuleManager();
            const auto UserIDs = GetUserIDs();
 
            for (auto ID : UserIDs)
            {
                // Do not send the event back to the caller.
                if (Caller.GetID() == ID)
                    continue;
 
                auto Resource = ModuleMgr.GetResource(ID);
 
                // Retry in case of Util::TimeoutException a couple of times to not lose events.
                for (int NumTries = 0; true; NumTries++)
                {
                    try
                    {
                        if (Resource->IsReady())
                            Resource->EnqueueEvent(std::make_unique<DerivedEvent>(InterModuleEvent));
                    }
                    catch ([[maybe_unused]] const Util::TimeoutException& e)
                    {
                        if (NumTries >= 100)
                            throw;
                        else
                        {
                            std::this_thread::yield();
 
                            continue;
                        }
                    }
 
                    break;
                }
            }
        }
 
    private:
        void ResetImpl(dispatch_tag<DynExp::InstrumentBase>) override final;
        virtual void ResetImpl(dispatch_tag<InterModuleCommunicator>) {}                
 
        // Do not override MakeInitTask(), MakeExitTask(), and MakeUpdateTask() since respective tasks don't do anything.
 
        const DynExp::DynExpCore& Core;                                                 
    };
}