MonitorPointAverageT.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITORPOINTAVERAGET_H
#define CARMA_MONITOR_MONITORPOINTAVERAGET_H

/*
 * MonitorPointAverageT.h - Template file for monitor point average
 * values of various types.
 */

#include "carma/monitor/types.h"
#include "carma/monitor/MonitorPoint.h"


namespace carma {
namespace monitor {


struct  AveProperties {
    int  nValidSamples; // # of samples not marked invalid in some fashion

    int  nTotalSamples; // total # of samples for this monitor point

    enum MonitorPoint::VALIDITY validity;

    // cumulative blanking for all valid samples
    enum MonitorPoint::BLANKING_FLAGGING blanking;
};


class MonitorPointAverageBase {
    public:

        int getNumTotalSamples( ) const;

        void setNumTotalSamples( int nTotalSamples );

        void incrementNumTotalSamples( int nTotalSamples = 1 );

        int getNumValidSamples( ) const;

        void setNumValidSamples( int nValidSamples );

        void incrementNumValidSamples( int nValidSamples = 1 );

        enum MonitorPoint::VALIDITY getValidity( ) const;

        void setValidity( enum MonitorPoint::VALIDITY validity );


        enum MonitorPoint::BLANKING_FLAGGING getBlanking( ) const;

        void setBlanking( enum MonitorPoint::BLANKING_FLAGGING blanking );

        ushort getDbBlanking( ) const;

        ushort getDbValidity( ) const;

        void writeAvePropsToFile( FILE * f ) const;

        void writeAvePropsToBuf( char * c ) const;

        void resetAveProperties( );

    protected:

        MonitorPointAverageBase( );

        ~MonitorPointAverageBase( );  // no v-table

    private:
        class TableInit;

        static ushort gBfToDbTable_[ MonitorPoint::MAX_BLANKING_FLAGGING ];
        static ushort gValToDbTable_[ MonitorPoint::MAX_VALIDITY ];

        static char gBfToDbFileTable_[ MonitorPoint::MAX_BLANKING_FLAGGING ][4];
        static char gValToDbFileTable_[ MonitorPoint::MAX_VALIDITY ][4];

        AveProperties properties_;
};


template < typename U >
class MonitorPointAverageT : public MonitorPointAverageBase {
    public:

        MonitorPointAverageT( const U & initialValue,
                              const U & max,
                              const U & min );

        MonitorPointAverageT( );

        ~MonitorPointAverageT( );  // no v-table


        U getAccumulator( ) const;

        void setAccumulator( const U & value );

        void incrementAccumulator(const U& value);


        U getMaxValue( ) const;

        void setMaxValue( const U & value );


        U getMinValue( ) const;

        void setMinValue( const U & value );


    private:
        U accumulator_;
        U maxValue_;
        U minValue_;
}; // template MonitorPointAverageT


} // end namespace monitor
} // end namespace carma


inline
carma::monitor::MonitorPointAverageBase::MonitorPointAverageBase( )
{
    resetAveProperties();
}


inline
carma::monitor::MonitorPointAverageBase::~MonitorPointAverageBase( )
{
}


inline void
carma::monitor::MonitorPointAverageBase::resetAveProperties( )
{
    properties_.nTotalSamples = 0;
    properties_.nValidSamples = 0;
    properties_.validity = MonitorPoint::INVALID_NO_DATA;
    properties_.blanking = MonitorPoint::UNDETERMINED;
}


inline int
carma::monitor::MonitorPointAverageBase::getNumTotalSamples( ) const
{
    return properties_.nTotalSamples;
}


inline void
carma::monitor::MonitorPointAverageBase::setNumTotalSamples(
    const int nTotalSamples )
{
    properties_.nTotalSamples = nTotalSamples;
}


inline void
carma::monitor::MonitorPointAverageBase::incrementNumTotalSamples(
    const int nTotalSamples )
{
    properties_.nTotalSamples += nTotalSamples;
}



inline int
carma::monitor::MonitorPointAverageBase::getNumValidSamples( ) const
{
    return properties_.nValidSamples;
}


inline void
carma::monitor::MonitorPointAverageBase::setNumValidSamples(
    const int nValidSamples )
{
    properties_.nValidSamples = nValidSamples;
}


inline void
carma::monitor::MonitorPointAverageBase::incrementNumValidSamples(
    const int nValidSamples )
{
    properties_.nValidSamples += nValidSamples;
}


inline enum carma::monitor::MonitorPoint::VALIDITY
carma::monitor::MonitorPointAverageBase::getValidity( ) const
{
    return properties_.validity;
}


inline void
carma::monitor::MonitorPointAverageBase::setValidity(
    const enum MonitorPoint::VALIDITY validity )
{
    properties_.validity = validity;
}



inline enum carma::monitor::MonitorPoint::BLANKING_FLAGGING
carma::monitor::MonitorPointAverageBase::getBlanking( ) const
{
    return properties_.blanking;
}


inline void
carma::monitor::MonitorPointAverageBase::setBlanking(
    const enum MonitorPoint::BLANKING_FLAGGING blanking )
{
    properties_.blanking = blanking;
}


inline ushort
carma::monitor::MonitorPointAverageBase::getDbBlanking( ) const
{
    const int bf = properties_.blanking;

    if ( (bf >= 0) && (bf < MonitorPoint::MAX_BLANKING_FLAGGING) )
        return gBfToDbTable_[ bf ];

    return gBfToDbTable_[ MonitorPoint::UNDETERMINED ];
}


inline ushort
carma::monitor::MonitorPointAverageBase::getDbValidity( ) const
{
    const int val = properties_.validity;

    if ( (val >= 0) && (val < MonitorPoint::MAX_VALIDITY) )
        return gValToDbTable_[ val ];

    return gValToDbTable_[ MonitorPoint::INVALID_NO_DATA ];
}


inline void
carma::monitor::MonitorPointAverageBase::writeAvePropsToFile( FILE * f ) const
{
    {
        const int bf = properties_.blanking;

        const char * sBf;
        if ( (bf >= 0) && (bf < MonitorPoint::MAX_BLANKING_FLAGGING) )
            sBf = gBfToDbFileTable_[ bf ];
        else
            sBf = gBfToDbFileTable_[ MonitorPoint::UNDETERMINED ];

        fputs( sBf, f );
    }

    {
        const int val = properties_.validity;

        const char * sVal;
        if ( (val >= 0) && (val < MonitorPoint::MAX_VALIDITY) )
            sVal = gValToDbFileTable_[ val ];
        else
            sVal = gValToDbFileTable_[ MonitorPoint::INVALID_NO_DATA ];

        fputs( sVal, f );
    }
}


inline void
carma::monitor::MonitorPointAverageBase::writeAvePropsToBuf( char * c ) const
{
    {
        const int bf = properties_.blanking;

        const char * sBf;
        if ( (bf >= 0) && (bf < MonitorPoint::MAX_BLANKING_FLAGGING) )
            sBf = gBfToDbFileTable_[ bf ];
        else
            sBf = gBfToDbFileTable_[ MonitorPoint::UNDETERMINED ];

        c[0] = sBf[0];
        c[1] = sBf[1];
        c[2] = sBf[2];
    }

    {
        const int val = properties_.validity;

        const char * sVal;
        if ( (val >= 0) && (val < MonitorPoint::MAX_VALIDITY) )
            sVal = gValToDbFileTable_[ val ];
        else
            sVal = gValToDbFileTable_[ MonitorPoint::INVALID_NO_DATA ];

        c[3] = sVal[0];
        c[4] = sVal[1];
        c[5] = sVal[2];
    }

    c[6] = '\0';
}


template< typename U >
inline
carma::monitor::MonitorPointAverageT< U >::MonitorPointAverageT(
    const U & initialValue,
    const U & max,
    const U & min ) :
accumulator_( initialValue ),
maxValue_( max ),
minValue_( min )
{
}


template< typename U >
inline
carma::monitor::MonitorPointAverageT< U >::~MonitorPointAverageT( )
{
}


template< typename U >
inline U
carma::monitor::MonitorPointAverageT< U >::getAccumulator( ) const
{
    return accumulator_ ;
}


template< typename U >
inline void
carma::monitor::MonitorPointAverageT< U >::setAccumulator( const U & value )
{
    accumulator_ = value;
}

template< typename U >
inline void
carma::monitor::MonitorPointAverageT<U>::incrementAccumulator(const U& value)
{
    accumulator_ += value;
}


template< typename U >
inline U
carma::monitor::MonitorPointAverageT< U >::getMaxValue( ) const
{
    return maxValue_ ;
}


template< typename U >
inline void
carma::monitor::MonitorPointAverageT< U >::setMaxValue( const U & value )
{
    maxValue_ = value;
}


template< typename U >
inline U
carma::monitor::MonitorPointAverageT< U >::getMinValue( ) const
{
    return minValue_ ;
}


template< typename U >
inline void
carma::monitor::MonitorPointAverageT< U >::setMinValue( const U & value )
{
    minValue_ = value;
}


// Specialize the default constructor to do the right thing for each type we
// care about

namespace carma {
namespace monitor {

template< >
inline
carma::monitor::MonitorPointAverageT< ::std::string >::
    MonitorPointAverageT( ) :
accumulator_(),
maxValue_(),
minValue_()
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< bool >::
    MonitorPointAverageT( ) :
accumulator_( false ),
maxValue_( false ),
minValue_( false )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< char >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< unsigned char >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< short >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< unsigned short >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< int >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< unsigned int >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< long >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< unsigned long >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< long long >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< unsigned long long >::
    MonitorPointAverageT( ) :
accumulator_( 0 ),
maxValue_( 0 ),
minValue_( 0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< float >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< double >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< long double >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< ::std::complex< float > >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< ::std::complex< double > >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


template< >
inline
carma::monitor::MonitorPointAverageT< ::std::complex< long double > >::
    MonitorPointAverageT( ) :
accumulator_( 0.0 ),
maxValue_( 0.0 ),
minValue_( 0.0 )
{
}


}} // namespace carma::monitor
#endif