MonitorPoint.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITORPOINT_H
#define CARMA_MONITOR_MONITORPOINT_H


#include <complex>
#include <string>

#include "carma/monitor/types.h"
#include "carma/monitor/MonitorComponent.h"
#include "carma/monitor/MonitorPointSample.h"
#include "carma/monitor/MonitorPointHeader.h"

namespace carma {
namespace monitor {

struct ScratchAverages;
class MonitorContainer;
class MonitorPointThreshold;

class MonitorPoint: public MonitorComponent {
public:

    enum VALIDITY {
        INVALID_NO_DATA,
        INVALID_NO_HW,
        INVALID_HW_BAD,
        VALID,
        VALID_NOT_CHECKED,
        VALID_GOOD,
        VALID_WARNING,
        VALID_ERROR,
        VALID_WARNING_LOW,
        VALID_WARNING_HIGH,
        VALID_ERROR_LOW,
        VALID_ERROR_HIGH,
        MAX_VALIDITY
    };

    enum BLANKING_FLAGGING {
        UNDETERMINED,
        OK,
        BLANKED,
        FLAGGED,
        BLANKED_FLAGGED,
        MAX_BLANKING_FLAGGING
    };

    enum MONITOR_POINT_TYPE {
        MONITOR,

        CONTROL
    };


    MonitorPoint( const std::string & name,
                  MonitorValueType    valuetype,
                  MONITOR_POINT_TYPE  monitorPointType = MONITOR );

    virtual ~MonitorPoint( );

    std::string getUnits() const;

    void setUnits(const std::string& units);

    void setWidth(short width) const;

    virtual short getWidth() const;

    void setPrecision(short precision);

    short getPrecision() const;

    void setPersistent(bool persistent) ;

    bool isPersistent( ) const;

    void setErrorHighDefault( const MonitorValue threshold );

    void setWarnHighDefault( const MonitorValue threshold );

    void setWarnLowDefault( const MonitorValue threshold );

    void setErrorLowDefault( const MonitorValue threshold );

    MonitorValue getErrorHighDefault () const;

    MonitorValue getWarnHighDefault () const;

    MonitorValue getWarnLowDefault () const;

    MonitorValue getErrorLowDefault () const;

    bool warnLowDefaultIsSet() const;

    bool errorLowDefaultIsSet() const;

    bool warnHighDefaultIsSet() const;

    bool errorHighDefaultIsSet() const;

    virtual void evaluateTolerance( const MonitorPointThreshold & threshold );

    void setComment( const std::string & text );

    void setComment( const std::string & text,
                     const std::string & user,
                     double              mjd );

    void clearComment( );

    std::string getComment() const;

    std::string getCommentUser() const;

    double getCommentTime() const;

    virtual void updateFrameAverage( ScratchAverages & scratchAvgs ) = 0;

    virtual std::string getValueToString(int sampleIndex) const = 0;

    virtual std::string getAverageToString() const = 0;

    std::string getPaddedValueString(int width, int sampleIndex) const;

    std::string getPaddedValueString(int sampleIndex) const;

    std::string getPaddedAverageString(int width) const;

    std::string getPaddedAverageString() const;

    std::string getCoreValueAsString( int sampleIndex = 0 ) const;

    virtual std::string toStringShort(int sampleIndex = 0) const;

    // Virtual, so doc is inherited
    std::string toString(bool canonicalName = false, bool verbose = false,
        bool value = true, int sampleIndex = 0, int indent = 0) const;

    // Virtual, so doc is inherited
    std::string toStringAverage(bool canonicalName = false,
        bool verbose = false, bool value = true, int indent = 0) const;

    // Virtual, so doc is inherited
    virtual std::string monitorPointTags(bool untagged = false) const;

    MonitorValueType getValuetype( ) const;

    MONITOR_POINT_TYPE getMonitorPointType( ) const;

    tagIDType getTagID( ) const;

    int getNumSamples( ) const;

    virtual void setNumSamples(int nSamples) const;

    VALIDITY getValidity( int sampleIndex ) const;
    VALIDITY getValidity( ) const;

    void setValidity(VALIDITY validity, int sampleIndex = 0) const;

    void setAllValidity(VALIDITY validity, bool markMpAsModified = true ) const;

    virtual VALIDITY getAveValidity() const;

    static bool isValid(VALIDITY validity) ;

    bool isAveValid() const;

    bool isValid( int sampleIndex ) const;
    bool isValid( ) const;

    void setAveValidity(VALIDITY validity) const;

    int getNumValidSamples() const;

    BLANKING_FLAGGING getBlankingFlagging() const;

    void setBlankingFlagging(BLANKING_FLAGGING flag) const;

    void setArchivePriority(ARCHIVE_PRIORITY priority);

    void setDefaultArchivePriority(ARCHIVE_PRIORITY priority);

    ARCHIVE_PRIORITY getArchivePriority( ) const;

    void setUpdateInterval(int interval);

    int getUpdateInterval( ) const;

    virtual void setTimeSeries(bool timeSeries);

    bool isTimeSeries( ) const;

    static std::string valuetypeToString(MonitorValueType valuetype);

    std::string valuetypeToString() const;

    static std::string monitorPointTypeToString(MONITOR_POINT_TYPE monitorPointType);

    std::string monitorPointTypeToString() const;

    static std::string validityToString(VALIDITY validity);

    static std::string blankingFlaggingToString(BLANKING_FLAGGING flag);

    std::string archivePriorityToString() const;

    virtual std::string dumpSamples(bool includeAverage  = true,
                                    bool includeValidity = true) const;

    void setMonitorPointHeader(MonitorPointHeader header);

    void setTagID(tagIDType tagID, bool      assignedOTF);

     void setSnapshotAverage(bool state);

     bool isSnapshotAverage() const;


//-----------------------------------------------------------------
// The methods that make this a monitor component

    // Specialize the docs..
    virtual bool operator==( const MonitorComponent & rhs ) const;

    virtual bool operator==( const MonitorPoint & rhs ) const;

    virtual bool operator<( const MonitorPoint & rhs ) const;

    // Virtual so docs are inherited
    void setNoData() const;

    // Virtual, so docs are inherited
    bool hasAllData() const;

    // Virtual, so docs are inherited
    virtual bool isMonitorPoint() const;


    void checkThreshold( const MonitorPointThreshold & threshold ) const;

    // Virtual, so doc is inherited
    virtual ::std::string hierarchyToString(
        bool canonical = false,
        bool verbose = false,
        bool value = true,
        int  sampleIndex = 0,
        int  indent = 0,
        int  levels = -1 ) const;

    // Virtual, so doc is inherited
    virtual void hierarchyToVector(
        ::std::vector< ::std::string > & hierarchyList,
        bool                             canonical = false,
        bool                             verbose = false,
        int                              sampleIndex = 0 ) const;

    // Virtual, so doc is inherited
    virtual ::std::string hierarchyToStringAverage(
        bool canonical = false,
        bool verbose = false,
        bool value = true,
        int  indent = 0,
        int  levels = -1 ) const;

    // Virtual, so doc is inherited
    virtual std::string leafToString( bool verbose = false,
                                      bool value = true,
                                      int sampleIndex = 0 ) const;
                                      
    MonitorPointSample getSampleAverage() const;

protected:

    void clearAllDefaults( );

public:

    MonitorPointSample getMonitorPointSample(int sampleIndex) const;
    MonitorPointSample getMonitorPointSample0() const;

protected:

    char                    getValueChar( int sampleIndex ) const;
    short                   getValueShort( int sampleIndex ) const;
    long                    getValueLong( int sampleIndex ) const;
    bool                    getValueBoolean( int sampleIndex ) const;
    float                   getValueFloat( int sampleIndex ) const;
    double                  getValueDouble( int sampleIndex ) const;
    ::std::complex< float > getValueComplex( int sampleIndex ) const;

    MonitorValueStringChunk getValueStringChunk( int sampleIndex ) const;

    long getValueSerialNo() const;

    void setValue( char d,                            int sampleIndex ) const;
    void setValue( short d,                           int sampleIndex ) const;
    void setValue( long d,                            int sampleIndex ) const;
    void setValue( bool d,                            int sampleIndex ) const;
    void setValue( float d,                           int sampleIndex ) const;
    void setValue( double d,                          int sampleIndex ) const;
    void setValue( const ::std::complex< float > & d, int sampleIndex ) const;

    void setValuesStringChunksAndValidities(
        const MonitorValueStringChunk * chunks,
        int                             numChunks,
        VALIDITY                        validity ) const;

    void setValueSerialNo( long d ) const;

    char                    getAveChar() const;
    short                   getAveShort() const;
    long                    getAveLong() const;
    bool                    getAveBoolean() const;
    float                   getAveFloat() const;
    double                  getAveDouble() const;
    ::std::complex< float > getAveComplex() const;
    long                    getAveSerialNo() const;

    void setAve( char d                            ) const;
    void setAve( short d                           ) const;
    void setAve( long d                            ) const;
    void setAve( bool d                            ) const;
    void setAve( float d                           ) const;
    void setAve( double d                          ) const;
    void setAve( const ::std::complex< float > & d ) const;

    void setAveSerialNo( long d ) const;

    bool isEqualTo( const MonitorPoint & mp ) const;
    std::string getSnapshotAverageToString() const;

private:
    explicit MonitorPoint( );

    // No copying
    MonitorPoint( const MonitorPoint & rhs );
    MonitorPoint & operator=( const MonitorPoint & rhs );

    std::string toString( bool canonicalName,
                          bool verbose,
                          bool value,
                          int  sampleIndex,
                          int  indent,
                          bool average ) const;

    struct CommentAttrs;
    struct DefThreshAttrs;

protected:
    bool                     timeSeries_;
    mutable short            width_;

private:
    std::string              units_;
    mutable short            precision_;
    bool                     persistent_;
    tagIDType                tagID_;
    const MonitorValueType   valuetype_;
    const MONITOR_POINT_TYPE monitorPointType_;
    MonitorPointHeader *     monitorPointHeader_;
    ARCHIVE_PRIORITY         archivePriority_;
    int                      updateInterval_;
    CommentAttrs *           commentAttrs_;
    bool                     snapshotAverage_;

    // These live here permanently - default values picked up from
    // mpml files.
    DefThreshAttrs *         defThreshAttrs_;
};


}  // namespace carma::monitor
}  // namespace carma


inline bool
carma::monitor::MonitorPoint::isTimeSeries( ) const
{
    return timeSeries_;
}


inline bool
carma::monitor::MonitorPoint::isPersistent( ) const
{
    return persistent_ ;
}


inline carma::monitor::tagIDType
carma::monitor::MonitorPoint::getTagID( ) const
{
    return tagID_;
}


inline carma::monitor::MonitorValueType
carma::monitor::MonitorPoint::getValuetype( ) const
{
    return valuetype_;
}


inline carma::monitor::MonitorPoint::MONITOR_POINT_TYPE
carma::monitor::MonitorPoint::getMonitorPointType( ) const
{
    return monitorPointType_;
}


inline carma::monitor::MonitorComponent::ARCHIVE_PRIORITY
carma::monitor::MonitorPoint::getArchivePriority( ) const
{
    return archivePriority_;
}


inline int
carma::monitor::MonitorPoint::getUpdateInterval( ) const
{
    return updateInterval_;
}


inline int
carma::monitor::MonitorPoint::getNumSamples( ) const
{
    return monitorPointHeader_->getNumSamplesPerCycle();
}

inline bool
carma::monitor::MonitorPoint::isSnapshotAverage( ) const
{
    return snapshotAverage_;
}


inline void
carma::monitor::MonitorPoint::setTagID(
    const carma::monitor::tagIDType tagId,
    const bool                      assignedOTF )
{
    tagID_ = tagId;

    // Do not archive if the tagID was assigned on-the-fly
    if ( assignedOTF )
        setArchivePriority( MonitorComponent::DONTARCHIVE );
}


inline carma::monitor::MonitorPointSample
carma::monitor::MonitorPoint::getSampleAverage( ) const
{
    return monitorPointHeader_->getSampleAverage();
}


inline bool
carma::monitor::MonitorPoint::isValid( const VALIDITY v )
{
    return ((v >= VALID) && (v < MAX_VALIDITY));
}


inline bool
carma::monitor::MonitorPoint::isAveValid( ) const
{
    return isValid( getAveValidity() );
}


inline carma::monitor::MonitorPoint::BLANKING_FLAGGING
carma::monitor::MonitorPoint::getBlankingFlagging( ) const
{
    return
        static_cast< BLANKING_FLAGGING >(
            getSampleAverage().getBlankingFlags() );
}


inline char
carma::monitor::MonitorPoint::getAveChar( ) const
{
    return getSampleAverage().getMonitorValue().byte;
}


inline short
carma::monitor::MonitorPoint::getAveShort( ) const
{
  return getSampleAverage().getMonitorValue().sh;
}


inline long
carma::monitor::MonitorPoint::getAveLong( ) const
{
    return getSampleAverage().getMonitorValue().lo;
}


inline bool
carma::monitor::MonitorPoint::getAveBoolean( ) const
{
    return getSampleAverage().getMonitorValue().bo;
}


inline float
carma::monitor::MonitorPoint::getAveFloat( ) const
{
    return getSampleAverage().getMonitorValue().fl;
}


inline double
carma::monitor::MonitorPoint::getAveDouble( ) const
{
    return getSampleAverage().getMonitorValue().db;
}


inline ::std::complex< float >
carma::monitor::MonitorPoint::getAveComplex( ) const
{
    const float * const c = getSampleAverage().getMonitorValue().complex;
    return ::std::complex< float >( c[0], c[1] );
}


inline long
carma::monitor::MonitorPoint::getAveSerialNo( ) const
{
    return getSampleAverage().getMonitorValue().sn;
}


#endif  // CARMA_MONITOR_MONITORPOINT_H