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 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);

    void Startup(void);

    void Initialize(void);

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

    mtsCollectorEvent(const std::string & collectorName,
                      const CollectorFileFormat fileFormat);

    ~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);

    void StartCollection(const mtsDouble & delayInSeconds);
    void StopCollection(const mtsDouble & delayInSeconds);

 protected:
    void SetCollecting(bool collecting, double currentTime);
};

CMN_DECLARE_SERVICES_INSTANTIATION(mtsCollectorEvent)

#endif // _mtsCollectorEvent_h