InputPort.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "DataStreamInstrument.h"
 
namespace DynExpInstr
{
    class InputPort;
 
    namespace InputPortTasks
    {
        class InitTask : public DataStreamInstrumentTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::InitTask>, DynExp::InstrumentInstance& Instance) override final;
            
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
            
 
            virtual bool ApplyDataStreamSizeFromParams() const noexcept { return true; }
        };
 
        class ExitTask : public DataStreamInstrumentTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
            
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DataStreamInstrumentTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<DataStreamInstrumentTasks::UpdateTask>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
            
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ResetBufferSizeTask final : public DynExp::TaskBase
        {
        public:
            ResetBufferSizeTask(CallbackType CallbackFunc) noexcept : TaskBase(CallbackFunc) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
        };
    }
 
    class InputPortData : public DataStreamInstrumentData
    {
    public:
        InputPortData(DataStreamBasePtrType&& SampleStream) : DataStreamInstrumentData(std::move(SampleStream)) {}
        
        virtual ~InputPortData() = default;
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrumentData>) override final;
        virtual void ResetImpl(dispatch_tag<InputPortData>) {};     
    };
 
    class InputPortParams : public DataStreamInstrumentParams
    {
    public:
        InputPortParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : DataStreamInstrumentParams(ID, Core) {}
 
        virtual ~InputPortParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "InputPortParams"; }
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<DataStreamInstrumentParams>) override final { ConfigureParamsImpl(dispatch_tag<InputPortParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<InputPortParams>) {}      
 
        DummyParam Dummy = { *this };                                           
    };
 
    class InputPortConfigurator : public DataStreamInstrumentConfigurator
    {
    public:
        using ObjectType = InputPort;
        using ParamsType = InputPortParams;
 
        InputPortConfigurator() = default;
        virtual ~InputPortConfigurator() = 0;
    };
 
    class InputPort : public DataStreamInstrument
    {
    public:
        using ParamsType = InputPortParams;                                     
        using ConfigType = InputPortConfigurator;                               
        using InstrumentDataType = InputPortData;                               
 
        using InitTaskType = InputPortTasks::InitTask;                          
        using ExitTaskType = InputPortTasks::ExitTask;                          
        using UpdateTaskType = InputPortTasks::UpdateTask;                      
 
        constexpr static auto Name() noexcept { return "Input Port"; }          
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        InputPort(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : DataStreamInstrument(OwnerThreadID, std::move(Params)) {}
 
        virtual ~InputPort() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
 
        virtual StreamSizeParamsExtension::ValueType GetStreamSizeParams() const { return { 1 }; }
 
        virtual DataStreamInstrumentData::ValueType GetHardwareMinValue() const = 0;
 
        virtual DataStreamInstrumentData::ValueType GetHardwareMaxValue() const = 0;
 
        virtual DataStreamInstrumentData::ValueType GetHardwareResolution() const = 0;
 
        virtual void ResetStreamSize(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const override { MakeAndEnqueueTask<InputPortTasks::ResetBufferSizeTask>(CallbackFunc); }
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrument>) override final;
        virtual void ResetImpl(dispatch_tag<InputPort>) = 0;                    
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<InputPortTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<InputPortTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<InputPortTasks::UpdateTask>(); }
    };
}