Component.h

Go to the documentation of this file.

#ifndef COMPONENT_H_
#define COMPONENT_H_

#include "component/FailureMode.h"
#include "data/DataElement.h"
#include "logger/Logger.h"
#include "utils/CodedStr.h"
#include "utils/FlexArray.h"
#include "utils/Str.h"
#include "utils/Timestamp.h"

class BlobReader;
class BlobWriter;
class ConfigReader;
class Module;
class UniversalBlobReader;
class UniversalBlobWriter;
class UniversalDataReader;
class UniversalDataWriter;

class Component
{
public:

    friend class AsyncComponent;
    friend class Config;
    friend class Behavior;
    friend class ScriptComponent;
    friend class SyncComponent;
    friend class ThreadHandler;

    virtual ~Component();

    void registerReader( DataReader *reader );
    void unregisterReader( DataReader *reader );
    void registerWriter( DataWriter *writer );
    void unregisterWriter( DataWriter *writer );
    void disableMetering( void )
    {
        meteringEnabled_ = false;
    }

    FlexArray<DataReader*> &getReaderList( void );
    FlexArray<DataWriter*> &getWriterList( void );

    const Module* getModule()
    {
        return module_;
    }

    enum ComponentState
    {
        BLOCK_CONTINUOUS,
        BLOCK_PERIODIC,
        BLOCK_NORMAL,
        BLOCK_COMPLETED,
        BLOCK_UNKNOWN
    };

    enum ComponentType
    {
        COMPONENT_ASYNC,
        COMPONENT_CONFIG,
        COMPONENT_BEHAVIOR,
        COMPONENT_SYNC
    };

    enum RunState
    {
        NO_RUN_STATE = 0, // Do not use runState -- use initialize, run, uninitialize
        START,        // Do what needs to be done to run
        STARTING,     // Might follow a STOP...START sequence
        RUNNABLE,     // Should eventually follow a START request or RESETTING
        SATISFIED,    // Possible return value of a Behavior with isSequence()=true.
        PAUSE,        // Pause for a short period (indicated by pauseTime)
        PAUSING,      // Might follow a PAUSE request
        PAUSED,       // Should eventually follow a PAUSE request, should set continueTime
        RESUME,     // Resume from PAUSE
        RESUMING,   // Might follow a PAUSE...RESUME sequence
        RESETTING,    // Might occur in case of Error
        STOP,         // Stop the execution of the component indefinitely
        STOPPING,     // Might follow a STOP request
        STOPPED,      // Should eventually follow a STOP request
    };

    virtual void initialize()
    {}

    virtual void configure()
    {}

    virtual void execute( void );

    virtual void run()
    {}

    virtual void uninitialize()
    {}

    //== Accessors ==

    bool isActive() const;

    const CodedStr& getName( void ) const
    {
        return name_;
    }

    const Timestamp& getTimeOfLastRun( void ) const
    {
        return timeOfLastRun_;
    }

    ComponentState getState( void )
    {
        return state_;
    };

    // Change the component's current state
    void setState( ComponentState state )
    {
        state_ = state;
    }

    RunState getRunState( void )
    {
        return runState_;
    };

    bool isUsingRunState()
    {
        return runState_ != NO_RUN_STATE;
    }

    void requestData( bool requestingData );

    void requestStart();

    void requestPause( const Timespan expectedPauseTime );

    void requestResume();

    void requestStop();

    virtual RunState start()
    {
        return RUNNABLE;
    }

    virtual RunState starting()
    {
        return RUNNABLE;
    }

    virtual RunState runnable()
    {
        return RUNNABLE;
    }

    virtual RunState satisfied()
    {
        return runnable();
    }

    virtual RunState pause()
    {
        return PAUSED;
    }

    virtual RunState pausing()
    {
        return PAUSED;
    }

    virtual RunState paused()
    {
        return PAUSED;
    }

    virtual RunState resume()
    {
        return RUNNABLE;
    }

    virtual RunState resuming()
    {
        return RUNNABLE;
    }

    virtual RunState resetting()
    {
        return RUNNABLE;
    }

    virtual RunState stop()
    {
        return STOPPED;
    }

    virtual RunState stopping()
    {
        return STOPPED;
    }

    virtual RunState stopped()
    {
        return STOPPED;
    }

    void setCriticalFailureReported( bool boolVal )
    {
        criticalFailureReported_ = boolVal;
    }

    void setRecoveringFromCritical( bool boolVal )
    {
        recoveringFromCritical_ = boolVal;
    }

    void setFailureReported( bool boolVal )
    {
        failureReported_ = boolVal;
    }

    bool isFailureUninitialized()
    {
        return failureUninitialized_;
    }

    void setFailureUninitialized( bool boolVal )
    {
        failureUninitialized_ = boolVal;
    }

    void setRetryTimeout( const Timespan& timeout )
    {
        retryTimeout_ = timeout;
    }

    virtual bool isCompleted( void )
    {
        return state_ == BLOCK_COMPLETED;
    }

    void setPeriod( const Timespan &period )
    {
        desiredPeriod_ = period;
    }

    const Timespan& getPeriod( void )
    {
        return desiredPeriod_;
    }

    ComponentType getComponentType()
    {
        return componentType_;
    }

    virtual bool isFailed( void ) const
    {
        return failureType_ != FailureMode::NONE;
    }

    virtual FailureMode::FailType getFailureType( void ) const
    {
        return failureType_;
    }

    virtual bool getCriticalFailureReported( void ) const
    {
        return criticalFailureReported_;
    }

    virtual bool getFailureReported( void ) const
    {
        return failureReported_;
    }

    virtual Timespan getRetryTimeout( void ) const
    {
        return retryTimeout_;
    }

    virtual FailureMode::FailType setFailure( FailureMode::FailType failureType );

    virtual int getFailCount( void ) const
    {
        return failCount_;
    }

    virtual bool isFailureMissionCritical()
    {
        return failureMissionCritical_;
    }

    virtual int getAllowableFailures( void ) const
    {
        return allowableFailures_;
    }

    virtual void setAllowableFailures( int fails )
    {
        allowableFailures_ = fails;
    }

    Logger &getLogger( void )
    {
        return logger_;
    }

    virtual int incrementFailCount( void )
    {
        return ++failCount_;
    }

    virtual void resetFailCount( void );

    virtual int getSkippedRunsSinceFail( void ) const
    {
        return skippedRunsSinceFail_;
    }

    virtual int incrementSkippedRunsSinceFail( void )
    {
        return ++skippedRunsSinceFail_;
    }

    virtual void logVoltage( float voltage, float averageVoltage );
    virtual void logCurrent( float current, float averageCurrent );

    const Timestamp& getWriteTimestamp( void )
    {
        return writeTimestamp_;
    }

    void setWriteTimestamp( const Timestamp& writeTimestamp )
    {
        writeTimestamp_ = writeTimestamp;
    }

    BlobReader* newBlobReader( const BlobURI& blobURI );

    BlobReader* newBlobReaderFromUniversal( const Str& componentName, const UniversalBlobURI& blobURI );

    BlobWriter* newBlobWriter( const BlobURI& blobURI,
                               Logger::TimePrecisionType timePrecision = Logger::TIME_PRECISION_MILLIS );

    ConfigReader* newConfigReader( const ConfigURI& configURI );

    DataReader* newDataReader( const DataURI& dataURI );

    DataReader* newDataReaderFromUniversal( const Str& componentName, const UniversalURI& universalURI );

    DataWriter* newDataWriter( const DataURI& dataURI,
                               Logger::TimePrecisionType timePrecision = Logger::TIME_PRECISION_MILLIS );

    UniversalBlobReader* newUniversalBlobReader( const UniversalBlobURI& universalURI );

    UniversalBlobWriter* newUniversalBlobWriter( const UniversalBlobURI& universalURI,
            const Unit& accuracyUnit = Units::NONE,
            const float accuracy = DataElement::NO_ACCURACY,
            Logger::TimePrecisionType timePrecision = Logger::TIME_PRECISION_MILLIS );

    UniversalDataReader* newUniversalReader( const UniversalURI& universalURI );

    UniversalDataWriter* newUniversalWriter( const UniversalURI& universalURI,
            const Unit& accuracyUnit = Units::NONE,
            const float accuracy = DataElement::NO_ACCURACY,
            Logger::TimePrecisionType timePrecision = Logger::TIME_PRECISION_MILLIS );

protected:

    enum ConfigOption
    {
        CONFIG_SIMULATE_HARDWARE,
        CONFIG_POWER,
        CONFIG_FREQUENCY,
        CONFIG_LATENCY,
    };

    virtual ConfigURI getConfigURI( ConfigOption configOption ) const
    {
        return ConfigURI::NO_CONFIG_URI;
    }

    virtual ConfigURI getConfigURI( ConfigOption configOption, ElementURI forElement ) const
    {
        return ConfigURI::NO_CONFIG_URI;
    }

    Logger logger_;

    // Set above Syslog::NONE to enable debug logging
    Syslog::Severity debugLevel_;

#define DEBUG_LOG(...) if(debugLevel_>Syslog::NONE){logger_.syslog(__VA_ARGS__,debugLevel_);}

    ComponentState state_;
    Timespan desiredPeriod_;

    CodedStr& name_;

    Timestamp timeOfRun_;
    Timestamp timeOfLastRun_;
    Timespan durationOfLastRun_;
    Timespan dt_;

    // How long to wait prior to re-trying to run the component after failure
    Timespan retryTimeout_;

    bool enabled_;

    bool failureReported_;

    bool criticalFailureReported_;

    bool recoveringFromCritical_;

    bool failureUninitialized_;

    int failCount_;

    bool failureMissionCritical_;

    int allowableFailures_;

    int skippedRunsSinceFail_;

    FailureMode::FailType failureType_;

    Timestamp timeOfFailure_;

    Timestamp writeTimestamp_;

    // I'm not sure this is the right way to go (embedding info in the Components)
    // as opposed to tracking elsewhere (i.e. some data structure in Slate)
    // but we'll start with this and see how Gordian things get
    FlexArray<DataReader*> readers_;
    FlexArray<DataWriter*> writers_;

    // The module that contains this component.
    // Can be NULL if no module contains the component.
    const Module* module_;

    Timespan pauseTime_;  // indication of how long to expect to be paused

    bool meteringEnabled_;

    //DataWriter *timeOfLastRunWriter_;        ///< Writer for timeOfLastRun
    //DataWriter *dtWriter_;                   ///< Writer for dt (time between runs)
    DataWriter *durationOfLastRunWriter_;      

    // Writers for load control values
    DataWriter *voltageWriter_;
    DataWriter *avgVoltageWriter_;
    DataWriter *currentWriter_;
    DataWriter *avgCurrentWriter_;

    bool persistentPause_;

    virtual void setDurationOfLastRun( const Timespan &span );

    virtual void setTimeOfRun( const Timestamp &time )
    {
        timeOfRun_ = time;
    }

    virtual void setTimeOfLastRun( const Timestamp &time );

    virtual void setDt( const Timespan &dt );

    virtual bool setEnabled( bool enabled = true )
    {
        enabled_ = enabled;
        return enabled_;
    }

    // Protected set the run state
    void setRunState( const RunState runState );

    // Protected read pauseTime
    const Timespan getPauseTime() const
    {
        return pauseTime_;
    }

    virtual void setFailureMissionCritical( bool failureMissionCritical )
    {
        failureMissionCritical_ = failureMissionCritical;
    }

    bool simulateHardware();

private:

    ComponentType componentType_;

    RunState runState_;  // indication of what state we are running in.

    ConfigReader* simulateHardwareReader_;

    int simulateHardware_;

    bool startRequested_; // true if a start is requested, but not yet possible.

    bool segfaultRequested_; // true if a segfault has been requested

    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    Component( const Component& old ); // disallow copy constructor

    Component( const Str& name, ComponentType componentType, const Module* module );

    friend class Handler;
    friend class CBIT;

    const Timestamp& getTimeOfFailure( void ) const
    {
        return timeOfFailure_;
    }

    virtual void setFailTime( Timestamp t )
    {
        timeOfFailure_ = t;
    }

    friend class CommandLine;

    void segfault()
    {
        segfaultRequested_ = true;
    }

    void segfaultImpl();

};

typedef FlexArray<Component *> ListOfComponents;

#endif /* COMPONENT_H_ */