monitorPointSpecializations.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITORPOINTSPECIALIZATIONS_H
#define CARMA_MONITOR_MONITORPOINTSPECIALIZATIONS_H


#include "carma/monitor/MonitorPointAverageT.h"
#include "carma/monitor/MonitorPointNumeric.h"


namespace carma {
namespace monitor {

class MonitorPointThreshold;

typedef MonitorPointAverageT< long > MonitorPointAverageBool;
typedef MonitorPointAverageT< int > MonitorPointAverageEnum;
typedef MonitorPointAverageT< long > MonitorPointAverageSerialNo;
typedef MonitorPointAverageT< ::std::string > MonitorPointAverageString;
typedef MonitorPointAverageT< ::std::complex< float > >
        MonitorPointAverageComplex;


class MonitorPointChar: public MonitorPointNumeric {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef char AccumReportType;

    MonitorPointChar(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointChar() {};

    void setValue(const char c, int sampleIndex = 0) const;

    char getValue(int sampleIndex = 0) const;

    char getAve() const;

    /*
     * Converts value to a string with both character value and hex
     * @param sampleIndex sample index (0 is first sample)
     */
    virtual std::string getValueToString(int sampleIndex = 0) const;

    /*
     * Converts average to a string with both character value and hex
     * @param sampleIndex sample index (0 is first sample)
     */
    virtual std::string getAverageToString() const;

    void setWarnLowDefault (const char threshold);

    void setWarnHighDefault (const char threshold);

    void setErrorLowDefault (const char threshold);

    void setErrorHighDefault (const char threshold);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold, char charVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);

private:
    /*
     * Converts to a string with both character value and hex
     * @param value
     */
    std::string getValueToString(char c) const;
};


class MonitorPointByte: public MonitorPointNumeric {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef unsigned char AccumReportType;

    MonitorPointByte(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointByte() {};

    void setValue(const unsigned char c, int sampleIndex = 0) const;

    unsigned char getValue(int sampleIndex = 0) const;

    unsigned char getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const unsigned char threshold);

    void setWarnHighDefault (const unsigned char threshold);

    void setErrorLowDefault (const unsigned char threshold);

    void setErrorHighDefault (const unsigned char threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
         (const MonitorPointThreshold& threshold, unsigned char byteVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);

};

class MonitorPointShort: public MonitorPointNumeric {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef short AccumReportType;

    MonitorPointShort(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    ~MonitorPointShort() {};

    void setValue(const short i, int sampleIndex = 0) const;

    short getValue(int sampleIndex = 0) const;

    short getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const short threshold);

    void setWarnHighDefault (const short threshold);

    void setErrorLowDefault (const short threshold);

    void setErrorHighDefault (const short threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                (const MonitorPointThreshold& threshold, short shortVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


};

class MonitorPointInt: public MonitorPointNumeric {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef long AccumReportType;

    MonitorPointInt(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    ~MonitorPointInt() {};

    void setValue(long i, int sampleIndex = 0) const;

    long getValue(int sampleIndex = 0) const;

    long getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const long threshold);

    void setWarnHighDefault (const long threshold);

    void setErrorLowDefault (const long threshold);

    void setErrorHighDefault (const long threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold, long longVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


};

class MonitorPointBool: public MonitorPoint {
public:
    typedef MonitorPointAverageBool AccumType;
    typedef bool AccumReportType;

    MonitorPointBool(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);

    virtual ~MonitorPointBool() {};

    void setValue(const bool b, int sampleIndex = 0) const;

    bool getValue(int sampleIndex = 0) const;

    virtual bool getAve() const;

    void setWarnLowDefault (bool boolVal);

    void setWarnHighDefault (bool boolVal);

    void setErrorLowDefault (bool boolVal);

    void setErrorHighDefault (bool boolVal);

    bool getWarnLow (const MonitorPointThreshold& threshold) const;

    bool getWarnHigh (const MonitorPointThreshold& threshold) const;

    bool getErrorLow (const MonitorPointThreshold& threshold) const;

    bool getErrorHigh (const MonitorPointThreshold& threshold) const;

    virtual void resetAccumulator (AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY accumulateSample
                       (AccumType & accum, int index) const;

    virtual void accumulate (AccumType & accum) const;

    virtual void accumulateAverage (AccumType & accum);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    // Already documented in base class
    virtual std::string getAverageToString() const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold, bool boolVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);

  private:

    int  nValidSamples_;
};


class MonitorPointEnum: public MonitorPoint {
public:
    typedef MonitorPointAverageEnum AccumType;
    typedef int AccumReportType;

    MonitorPointEnum(const std::string& name,
        const bool bitmask = false,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);

    ~MonitorPointEnum() {};

    bool isBitmask() const { return this->bitmask_; }

    virtual short getWidth() const;

    void setNumEnumerations(int num);

    int getNumEnumerations() const;

    void addEnumWarnLowDefault (const long enumValue);

    void removeEnumWarnLowDefault (const long enumValue);

    void addEnumWarnHighDefault (const long enumValue);

    void removeEnumWarnHighDefault (const long enumValue);

    void addEnumErrorLowDefault (const long enumValue);

    void removeEnumErrorLowDefault (const long enumValue);

    void addEnumErrorHighDefault (const long enumValue);

    void removeEnumErrorHighDefault (const long enumValue);

    virtual void resetAccumulator (AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY accumulateSample
                       (AccumType & accum, int index) const;

    virtual void accumulate (AccumType & accum) const;

    virtual void accumulateAverage (AccumType & accum);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Default implementation that inserts the maximum value
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold, int enumVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);

    ::std::string getRawStringForEnumValue( int enumValue ) const;

    void setValue(const long i, int sampleNo) const;
    int  getValue(int sampleNo) const;
    int  getAve() const;

protected:

    virtual std::string convertToString(int enumValue) const = 0;

private:
    int  nEnumerations_;
    int  nValidSamples_;
    const bool bitmask_;
};

class MonitorPointReal: public MonitorPointNumeric {
public:

    MonitorPointReal(const std::string& name, MonitorValueType monitorValueType,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointReal() {};

};

class MonitorPointFloat: public MonitorPointReal {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef float AccumReportType;

    MonitorPointFloat(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointFloat() {};

    void setValue(const float f, int sampleIndex = 0) const;

    float getValue(int sampleIndex = 0) const;

    float getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const float threshold);

    void setWarnHighDefault (const float threshold);

    void setErrorLowDefault (const float threshold);

    void setErrorHighDefault (const float threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                (const MonitorPointThreshold& threshold, float floatVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


};

class MonitorPointDouble: public MonitorPointReal {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef double AccumReportType;

    MonitorPointDouble(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointDouble() {};

    void setValue(const double f, int sampleIndex = 0) const;

    double getValue(int sampleIndex = 0) const;

    double getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const double threshold);

    void setWarnHighDefault (const double threshold);

    void setErrorLowDefault (const double threshold);

    void setErrorHighDefault (const double threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
             (const MonitorPointThreshold& threshold, double doubleVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


};

class MonitorPointComplex: public MonitorPoint {
public:
    typedef MonitorPointAverageComplex AccumType;
    typedef ::std::complex< float > AccumReportType;

    typedef enum stringValueEnum {

        AMP,
        PHASE,
        REAL,
        IMAG,
        COMPLEX

    } stringValueReturnType;

    MonitorPointComplex(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    virtual ~MonitorPointComplex() {};

    void setValue(const std::complex<float>& f, int sampleIndex = 0) const;

    std::complex<float> getValue(int sampleIndex = 0) const;

    std::complex<float> getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const float threshold);

    void setWarnHighDefault (const float threshold);

    void setErrorLowDefault (const float threshold);

    void setErrorHighDefault (const float threshold);


    // Already documented in base class
    virtual std::string getAverageToString() const;

    virtual void resetAccumulator (AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY accumulateSample
                       (AccumType & accum, int index) const;

    virtual void accumulate (AccumType & accum) const;

    virtual void accumulateAverage (AccumType & accum);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold,
                            std::complex<float> complexVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


    void setPrecision(short precision);

    short getPrecision() const;

    bool operator==(const MonitorComponent& component) const;

    void setStringRepresentation(const stringValueReturnType& type);

    stringValueReturnType getStringRepresentation(void) const;

protected:

    std::complex<float> getMaxSampleValue () const;

    std::complex<float> getMinSampleValue () const;

private:
    int  nValidSamples_;
    short precision_;
    stringValueReturnType stringReturnType_;
    std::string getValueToString(std::complex<float> f) const;
};

class MonitorPointAbstime: public MonitorPointReal {
public:
    typedef MonitorPointAverageNumeric AccumType;
    typedef double AccumReportType;

    MonitorPointAbstime(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);

    enum ABSTIME_FORMAT {
        DATE,
        TIME,
        DATE_AND_TIME
    };

    virtual ~MonitorPointAbstime() {};

    void setFormat(ABSTIME_FORMAT format);

    ABSTIME_FORMAT getFormat() const;

    std::string getFormattedAbstime(double mjd) const;

    void setValue(const double f, int sampleIndex = 0) const;

    double getValue(int sampleIndex = 0) const;

    double getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    void setWarnLowDefault (const double threshold);

    void setWarnHighDefault (const double threshold);

    void setErrorLowDefault (const double threshold);

    void setErrorHighDefault (const double threshold);

    // Already documented in base class
    virtual std::string getAverageToString() const;

    // Already documented in base class
    virtual double getValueNumeric( int sampleIndex ) const;

    // Already documented in base class
    virtual double getAveNumeric( ) const;

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
              (const MonitorPointThreshold& threshold, double abstimeVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);

private:
    ABSTIME_FORMAT format_;

};

class MonitorPointRA: public MonitorPointDouble {
public:
    MonitorPointRA(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);

    virtual ~MonitorPointRA() {};
    // Already documented in base class
    virtual std::string getAverageToString() const;
};
class MonitorPointDec: public MonitorPointDouble {
public:
    MonitorPointDec(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);

    virtual ~MonitorPointDec() {};
    // Already documented in base class
    virtual std::string getAverageToString() const;
};

class MonitorPointString: public MonitorPoint {
public:
    typedef MonitorPointAverageString AccumType;
    typedef ::std::string AccumReportType;

    MonitorPointString(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    ~MonitorPointString() {};

    void setValue(const std::string& str) const;

    std::string getValue() const;

    std::string getAve() const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex) const;

    std::string getValueToString() const;

    // Already documented in base class
    virtual std::string getAverageToString() const;

    void setWarnLowDefault (const std::string strValue);

    void setWarnHighDefault (const std::string strValue);


    void setErrorLowDefault (const std::string strValue);

    void setErrorHighDefault (const std::string strValue);

    std::string getWarnLow (const MonitorPointThreshold& threshold) const;

    std::string getWarnHigh (const MonitorPointThreshold& threshold) const;

    std::string getErrorLow (const MonitorPointThreshold& threshold) const;

    std::string getErrorHigh (const MonitorPointThreshold& threshold) const;

    virtual void resetAccumulator (AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY accumulateSample
                       (AccumType & accum, int index) const;

    virtual void accumulate (AccumType & accum) const;

    virtual void accumulateAverage (AccumType & accum);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold,
                                     std::string stringVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


    bool operator==(const MonitorComponent& component) const;

};

class MonitorPointSerialNo: public MonitorPoint {
public:
    typedef MonitorPointAverageSerialNo AccumType;
    typedef long AccumReportType;

    MonitorPointSerialNo(const std::string& name,
        MONITOR_POINT_TYPE monitorPointType = MONITOR);


    ~MonitorPointSerialNo() {};

    void setValue(long i, int sampleIndex = 0) const;

    int getValue(int sampleIndex = 0) const;

    int getAve() const;

    void setNumSamples(int nSamples) const;

    // Already documented in base class
    virtual std::string getValueToString(int sampleIndex = 0) const;

    // Already documented in base class
    virtual std::string getAverageToString() const;

    virtual void resetAccumulator (AccumType & accum) const;

    virtual enum MonitorPoint::VALIDITY accumulateSample
                       (AccumType & accum, int index) const;

    virtual void accumulate (AccumType & accum) const;

    virtual void accumulateAverage (AccumType & accum);

    virtual std::string getAccumulatedAverageAsString (const AccumType & accum) const;

    virtual AccumReportType getAccumulatedAverage (const AccumType & accum) const;

    virtual AccumReportType getMaxValue (const AccumType & accum) const;

    virtual AccumReportType getMinValue (const AccumType & accum) const;

    // Already documented in base class
    virtual void updateFrameAverage( ScratchAverages & scratchAvgs );

    virtual enum MonitorPoint::VALIDITY evaluateSampleTolerance
                  (const MonitorPointThreshold& threshold, long serialNoVal) const;

    // documented in base class
    virtual void evaluateTolerance (const MonitorPointThreshold& threshold);


};


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


inline char
carma::monitor::MonitorPointChar::getAve( ) const
{
    return getAveChar();
}


inline unsigned char
carma::monitor::MonitorPointByte::getAve( ) const
{
    return static_cast< unsigned char >( getAveChar() );
}


inline short
carma::monitor::MonitorPointShort::getAve( ) const
{
    return getAveShort();
}


inline long
carma::monitor::MonitorPointInt::getAve( ) const
{
    return getAveLong();
}


inline int
carma::monitor::MonitorPointEnum::getAve( ) const
{
    return getAveLong();
}


inline float
carma::monitor::MonitorPointFloat::getAve( ) const
{
    return getAveFloat();
}


inline double
carma::monitor::MonitorPointDouble::getAve( ) const
{
    return getAveDouble();
}


inline ::std::complex< float >
carma::monitor::MonitorPointComplex::getAve( ) const
{
    return getAveComplex();
}


inline double
carma::monitor::MonitorPointAbstime::getAve( ) const
{
    return getAveDouble();
}


inline ::std::string
carma::monitor::MonitorPointString::getAve( ) const
{
    return getValue();
}


inline int
carma::monitor::MonitorPointSerialNo::getAve( ) const
{
    return getAveSerialNo();
}


#endif