Adapter.h

#pragma once

namespace AnimatSim
{

        namespace Adapters
        {
                
                enum eDelayBufferMode
                {
                        NoDelayBuffer,
                        DelayBufferInSimOnly,
                        DelayBufferAlwaysOn
                };

                class ANIMAT_PORT Adapter : public Node 
                {
                protected:
                        std::string m_strSourceModule;

                        std::string m_strSourceID;

                        std::string m_strSourceDataType;

                        Node *m_lpSourceNode;

                        float *m_lpSourceData;

                        std::string m_strTargetModule;

                        std::string m_strTargetID;

                        std::string m_strTargetDataType;

                        int m_iTargetDataType;

                        Node *m_lpTargetNode;

                        Gain *m_lpGain;

                        bool m_bConnectedToPhysics;

                        float m_fltCalculatedVal;

                        float m_fltNextVal;

                        //Determines whether this adapter uses a delay buffer. 
                        eDelayBufferMode m_eDelayBufferMode;

                        //The duration of the delay buffer.
                        float m_fltDelayBufferInterval;

                        CStdCircularArray<float> m_aryDelayBuffer;

                        bool m_bSynchWithRobot;

                        float m_fltSynchUpdateInterval;

                        int m_iSynchUpdateInterval;

                        float m_fltSynchUpdateStartInterval;

                        int m_iSynchUpdateStartInterval;

                        int m_iSynchTarget;

                        int m_iSynchCount;

                        float m_fltRobotIOScale;

                        float m_fltInitIODisableDuration;

                        float m_fltUpdatedValue;

                        virtual void AddGain(std::string strXml);
                        virtual void SetOriginID(std::string strXml);
                        virtual void SetDestinationID(std::string strXml);

                        virtual void SetDelayBufferSize();

                        virtual bool NeedsRobotSynch();

                        virtual void ApplyExternalNodeInput(int iTargetDataType, float fltNextVal);

                public:
                        Adapter();
                        virtual ~Adapter();
                                                        
                        static Adapter *CastToDerived(AnimatBase *lpBase) {return static_cast<Adapter*>(lpBase);}

                        virtual std::string SourceModule();
                        virtual void SourceModule(std::string strName);

                        virtual std::string SourceID();
                        virtual void SourceID(std::string strID);

                        virtual std::string SourceDataType();
                        virtual void SourceDataType(std::string strType);

                        virtual Node *SourceNode();

                        virtual std::string TargetModule();
                        virtual void TargetModule(std::string strName);

                        virtual std::string TargetID();
                        virtual void TargetID(std::string strID);

                        virtual std::string TargetDataType();
                        virtual void TargetDataType(std::string strType);

                        virtual Node *TargetNode();

                        virtual Gain *GetGain();
                        virtual void SetGain(Gain *lpGain);

                        virtual bool ConnectedToPhysics();

                        virtual eDelayBufferMode DelayBufferMode();
                        virtual void DelayBufferMode(eDelayBufferMode eMode);

                        virtual float DelayBufferInterval();
                        virtual void DelayBufferInterval(float fltVal);

                        virtual void DetachAdaptersFromSimulation();

                        virtual float RobotIOScale();
                        virtual void RobotIOScale(float fltVal);

                        virtual bool SynchWithRobot();
                        virtual void SynchWithRobot(bool bVal);

                        virtual float SynchUpdateInterval();
                        virtual void SynchUpdateInterval(float fltVal);

                        virtual float SynchUpdateStartInterval();
                        virtual void SynchUpdateStartInterval(float fltVal);

                        virtual float InitIODisableDuration();
                        virtual void InitIODisableDuration(float fltVal);

                        virtual void Initialize();
                        virtual void TimeStepModified();
                        virtual void ResetSimulation();
                        virtual void AddExternalNodeInput(int iTargetDataType, float fltInput);
                        virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                        virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);
                        virtual float *GetDataPointer(const std::string &strDataType);
                        virtual void StepSimulation();
                        virtual void Load(CStdXml &oXml);
                };

        }                       //Adapters
}                               //AnimatSim