mtsCollectorEvent.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: 2010-02-12
 
  (C) Copyright 2010-2025 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 _mtsCollectorEvent_h
#define _mtsCollectorEvent_h
 
#include <cisstMultiTask/mtsTaskPeriodic.h>
#include <cisstMultiTask/mtsCollectorBase.h>
#include <cisstMultiTask/mtsCommandVoid.h>
#include <cisstMultiTask/mtsStateTable.h>
 
#include <string>
 
// Always include last
#include <cisstMultiTask/mtsExport.h>

class CISST_EXPORT mtsCollectorEvent : public mtsCollectorBase
{
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);
 
 protected:

    mtsComponent * CheckComponent(const std::string & componentName) const;
    mtsInterfaceProvided * CheckInterface(const mtsComponent * componentPointer,
                                          const std::string & interfaceName) const;

    typedef cmnNamedMap<mtsInterfaceRequired> InterfacesRequiredMap;
    typedef cmnNamedMap<InterfacesRequiredMap> ComponentsMap;
    ComponentsMap ObservedComponents;

    mtsInterfaceRequired * GetInterfaceRequiredFor(const mtsComponent * componentPointer,
                                                   const mtsInterfaceProvided * interfacePointer);

    class CollectorEventVoid {
    public:
        std::string ComponentName;
        std::string InterfaceName;
        std::string EventName;
        size_t EventId;
        mtsCollectorEvent * Collector;
        CollectorEventVoid(const std::string & componentName, const std::string & interfaceName, const std::string & eventName,
                           size_t eventId, mtsCollectorEvent * collector);
        void EventHandler(void);
        void PrintHeader(std::ostream & outputStream, const CollectorFileFormat fileFormat);
    };

    void SaveEventVoid(const CollectorEventVoid * event);

    class CollectorEventWrite {
    public:
        std::string ComponentName;
        std::string InterfaceName;
        std::string EventName;
        mtsInterfaceRequired * InterfaceRequired;
        const mtsGenericObject * ArgumentPrototype;
        size_t EventId;
        mtsCollectorEvent * Collector;
        CollectorEventWrite(const std::string & componentName, const std::string & interfaceName, const std::string & eventName,
                            size_t eventId, mtsCollectorEvent * collector);
        void EventHandler(const mtsGenericObject & payload);
        void PrintHeader(std::ostream & outputStream, const CollectorFileFormat fileFormat);
    };

    void SaveEventWrite(const CollectorEventWrite * event, const mtsGenericObject & payload);

    size_t EventCounter;

    std::vector<CollectorEventVoid *> EventsVoid;
    std::vector<CollectorEventWrite *> EventsWrite;

    bool Collecting;

    double ScheduledStartTime;

    double ScheduledStopTime;

    bool CheckCollectingStatus(void);

    const osaTimeServer * TimeServer;
 
 public:
    void Run(void) override;
 
    void Startup(void) override;

    void Initialize(void);
 
    // documented in base class
    virtual std::string GetDefaultOutputName(void) override;

    mtsCollectorEvent(const std::string & collectorName,
                      const CollectorFileFormat fileFormat = mtsCollectorBase::COLLECTOR_FILE_FORMAT_CSV);
 
    ~mtsCollectorEvent(void);

    bool AddObservedComponent(const std::string & componentName);

    bool AddObservedComponent(const mtsComponent * componentPointer);

    bool AddObservedInterface(const std::string & componentName,
                              const std::string & interfaceName);
 
 protected:
    bool AddObservedInterface(const mtsComponent * componentPointer,
                              const mtsInterfaceProvided * interfacePointer);
 
 public:
    bool AddObservedEventVoid(const std::string & componentName,
                              const std::string & interfaceName,
                              const std::string & eventName);
    bool AddObservedEventWrite(const std::string & componentName,
                               const std::string & interfaceName,
                               const std::string & eventName);
 
 protected:
    bool AddObservedEventVoid(const mtsComponent * componentPointer,
                              const mtsInterfaceProvided * interfacePointer,
                              const std::string & eventName);
    bool AddObservedEventWrite(const mtsComponent * componentPointer,
                               const mtsInterfaceProvided * interfacePointer,
                               const std::string & eventName);

    void PrintHeader(const CollectorFileFormat & fileFormat);
 
 public:
    bool Connect(void) override;

    void StartCollection(const double & delayInSeconds) override;
    void StopCollection(const double & delayInSeconds) override;
 
 protected:
    void SetCollecting(bool collecting, double currentTime);
};
 
CMN_DECLARE_SERVICES_INSTANTIATION(mtsCollectorEvent)
 
#endif // _mtsCollectorEvent_h