OutputPort.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "FunctionGenerator.h"
 
namespace DynExpInstr
{
    class OutputPort;
 
    namespace OutputPortTasks
    {
        class InitTask : public FunctionGeneratorTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<FunctionGeneratorTasks::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 FunctionGeneratorTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<FunctionGeneratorTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
            
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public FunctionGeneratorTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<FunctionGeneratorTasks::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 OutputPortData : public FunctionGeneratorData
    {
    public:
        OutputPortData(DataStreamBasePtrType&& SampleStream) : FunctionGeneratorData(std::move(SampleStream)) {}
        
        virtual ~OutputPortData() = default;
 
    private:
        void ResetImpl(dispatch_tag<FunctionGeneratorData>) override final;
        virtual void ResetImpl(dispatch_tag<OutputPortData>) {};    
    };
 
    class OutputPortParams : public FunctionGeneratorParams
    {
    public:
        OutputPortParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : FunctionGeneratorParams(ID, Core) {}
        
        virtual ~OutputPortParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "OutputPortParams"; }
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<FunctionGeneratorParams>) override final { ConfigureParamsImpl(dispatch_tag<OutputPortParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<OutputPortParams>) {}     
 
        DummyParam Dummy = { *this };                                           
    };
 
    class OutputPortConfigurator : public FunctionGeneratorConfigurator
    {
    public:
        using ObjectType = OutputPort;
        using ParamsType = OutputPortParams;
 
        OutputPortConfigurator() = default;
        virtual ~OutputPortConfigurator() = 0;
    };
 
    class OutputPort : public FunctionGenerator
    {
    public:
        using ParamsType = OutputPortParams;                                    
        using ConfigType = OutputPortConfigurator;                              
        using InstrumentDataType = OutputPortData;                              
 
        using InitTaskType = OutputPortTasks::InitTask;                         
        using ExitTaskType = OutputPortTasks::ExitTask;                         
        using UpdateTaskType = OutputPortTasks::UpdateTask;                     
 
        constexpr static auto Name() noexcept { return "Output Port"; }         
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        OutputPort(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : FunctionGenerator(OwnerThreadID, std::move(Params)) {}
 
        virtual ~OutputPort() = 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 DataStreamInstrumentData::ValueType GetUserMinValue() const = 0;
 
        virtual DataStreamInstrumentData::ValueType GetUserMaxValue() const = 0;
 
        virtual void ResetStreamSize(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const override { MakeAndEnqueueTask<OutputPortTasks::ResetBufferSizeTask>(CallbackFunc); }
 
    private:
        void ResetImpl(dispatch_tag<FunctionGenerator>) override final;
        virtual void ResetImpl(dispatch_tag<OutputPort>) = 0;                   
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<OutputPortTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<OutputPortTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<OutputPortTasks::UpdateTask>(); }
    };
}