mtsComponentAddLatency.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Anton Deguet
  Created on: 2011-12-15
 
  (C) Copyright 2011-2023 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 
 
#ifndef _mtsComponentAddLatency_h
#define _mtsComponentAddLatency_h
 
#include <cisstMultiTask/mtsTaskPeriodic.h>
#include <cisstMultiTask/mtsInterfaceProvided.h>
 
// Always include last
#include <cisstMultiTask/mtsExport.h>
 
// forward declarations for internal types
class mtsComponentAddLatencyDelayedRead;
class mtsComponentAddLatencyDelayedQualifiedRead;
class mtsComponentAddLatencyDelayedVoid;
class mtsComponentAddLatencyDelayedWrite;

class CISST_EXPORT mtsComponentAddLatency: public mtsTaskPeriodic
{
    CMN_DECLARE_SERVICES(CMN_DYNAMIC_CREATION_ONEARG, CMN_LOG_ALLOW_DEFAULT);
 
 protected:
 
    typedef std::list<mtsComponentAddLatencyDelayedRead *> DelayedReadList;
    DelayedReadList DelayedReads;
 
    typedef std::list<mtsComponentAddLatencyDelayedQualifiedRead *> DelayedQualifiedReadList;
    DelayedQualifiedReadList DelayedQualifiedReads;
 
    typedef std::list<mtsComponentAddLatencyDelayedVoid *> DelayedVoidList;
    DelayedVoidList DelayedVoids;
 
    typedef std::list<mtsComponentAddLatencyDelayedWrite *> DelayedWriteList;
    DelayedWriteList DelayedWrites;
 
 public:
    // constructor
    mtsComponentAddLatency(const std::string & componentName, double periodInSeconds);
    mtsComponentAddLatency(const mtsTaskPeriodicConstructorArg &arg);
    virtual ~mtsComponentAddLatency();
 
    // methods defined as virtual in base class
    void Configure(const std::string & filename) override;
    void Startup(void) override;
    void Run(void) override;
    void Cleanup(void) override;
 
    double SetLatency(double latencyInSeconds);
 
 protected:

    template <class _elementType>
    bool AddCommandReadDelayed(mtsInterfaceRequired * interfaceRequired,
                               const std::string & commandRequiredName,
                               mtsInterfaceProvided * interfaceProvided,
                               const std::string & commandProvidedName = "");
 
    template <class _element1Type, class _element2Type>
    bool AddCommandQualifiedReadDelayed(mtsInterfaceRequired * interfaceRequired,
                                        const std::string & commandRequiredName,
                                        mtsInterfaceProvided * interfaceProvided,
                                        const std::string & commandProvidedName = "");
 
 
    bool AddCommandVoidDelayed(mtsInterfaceRequired * interfaceRequired,
                               const std::string & commandRequiredName,
                               mtsInterfaceProvided * interfaceProvided,
                               const std::string & commandProvidedName = "");
 
    template <class _elementType>
    bool AddCommandWriteDelayed(mtsInterfaceRequired * interfaceRequired,
                                const std::string & commandRequiredName,
                                mtsInterfaceProvided * interfaceProvided,
                                const std::string & commandProvidedName = "");
 
    bool AddEventVoidDelayed(mtsInterfaceRequired * interfaceRequired,
                             const std::string & eventRequiredName,
                             mtsInterfaceProvided * interfaceProvided,
                             const std::string & eventProvidedName = "");
 
    template <class _elementType>
    bool AddEventWriteDelayed(mtsInterfaceRequired * interfaceRequired,
                              const std::string & eventRequiredName,
                              mtsInterfaceProvided * interfaceProvided,
                              const std::string & eventProvidedName = "");
 
    double Latency;
    mtsStateTable LatencyStateTable;
 
 private:
    bool AddCommandReadDelayedInternal(mtsGenericObject & data,
                                       mtsInterfaceRequired * interfaceRequired,
                                       const std::string & commandRequiredName);
 
    bool AddCommandQualifiedReadDelayedInternal(const mtsGenericObject & qualifier,
                                                const mtsGenericObject & placeHolder,
                                                mtsInterfaceRequired * interfaceRequired,
                                                const std::string & commandRequiredName,
                                                mtsInterfaceProvided * interfaceProvided,
                                                const std::string & commandProvidedName);
 
    bool AddCommandWriteDelayedInternal(const mtsGenericObject & data,
                                        mtsInterfaceRequired * interfaceRequired,
                                        const std::string & commandRequiredName,
                                        mtsInterfaceProvided * interfaceProvided,
                                        const std::string & commandProvidedName);
 
    bool AddEventWriteDelayedInternal(const mtsGenericObject & data,
                                      mtsInterfaceRequired * interfaceRequired,
                                      const std::string & eventRequiredName,
                                      mtsInterfaceProvided * interfaceProvided,
                                      const std::string & eventProvidedName = "");
 
};
 
 
 
template <class _elementType>
bool mtsComponentAddLatency::AddCommandReadDelayed(mtsInterfaceRequired * interfaceRequired,
                                                   const std::string & commandRequiredName,
                                                   mtsInterfaceProvided * interfaceProvided,
                                                   const std::string & commandProvidedName)
{
    // data object is used later to store the result of function
    // reads, state teble will keep a pointer on that object so it
    // must not be deleted until the task is killed.
    _elementType * data = new _elementType;
    this->LatencyStateTable.AddData(*data);
    interfaceProvided->AddCommandReadStateDelayed(this->LatencyStateTable,
                                                  *data,
                                                  commandProvidedName == ""
                                                  ? commandRequiredName
                                                  : commandProvidedName);
    return
        this->AddCommandReadDelayedInternal(*data, interfaceRequired, commandRequiredName);
}
 
 
template <class _element1Type, class _element2Type>
bool mtsComponentAddLatency::AddCommandQualifiedReadDelayed(mtsInterfaceRequired * interfaceRequired,
                                                            const std::string & commandRequiredName,
                                                            mtsInterfaceProvided * interfaceProvided,
                                                            const std::string & commandProvidedName)
{
    _element1Type qualifier;
    _element2Type placeHolder;
    return
        this->AddCommandQualifiedReadDelayedInternal(qualifier,
                                                     placeHolder,
                                                     interfaceRequired,
                                                     commandRequiredName,
                                                     interfaceProvided,
                                                     commandProvidedName == ""
                                                     ? commandRequiredName
                                                     : commandProvidedName);
}
 
 
template <class _elementType>
bool mtsComponentAddLatency::AddCommandWriteDelayed(mtsInterfaceRequired * interfaceRequired,
                                                    const std::string & commandRequiredName,
                                                    mtsInterfaceProvided * interfaceProvided,
                                                    const std::string & commandProvidedName)
{
    // data object is used to create an argument prototype but won't
    // be used afterwards
    _elementType data;
    return
        this->AddCommandWriteDelayedInternal(data,
                                             interfaceRequired,
                                             commandRequiredName,
                                             interfaceProvided,
                                             commandProvidedName == ""
                                             ? commandRequiredName
                                             : commandProvidedName);
}
 
 
template <class _elementType>
bool mtsComponentAddLatency::AddEventWriteDelayed(mtsInterfaceRequired * interfaceRequired,
                                                  const std::string & eventRequiredName,
                                                  mtsInterfaceProvided * interfaceProvided,
                                                  const std::string & eventProvidedName)
{
    // data object is used to create an argument prototype but won't
    // be used afterwards
    _elementType data;
    return
        this->AddEventWriteDelayedInternal(data,
                                           interfaceRequired,
                                           eventRequiredName,
                                           interfaceProvided,
                                           eventProvidedName == ""
                                           ? eventRequiredName
                                           : eventProvidedName);
}
 
 
CMN_DECLARE_SERVICES_INSTANTIATION(mtsComponentAddLatency)
 
 
#endif // _mtsComponentAddLatency_h