MonitorPointHeader.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITOR_POINT_HEADER_H
#define CARMA_MONITOR_MONITOR_POINT_HEADER_H

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


namespace carma  {
  namespace monitor  {


class MonitorPointSet;


struct MonitorHeader {
    tagIDType tagID;

    ushort sampleOffset;

    unsigned char nSamples;

    unsigned char type;
    
    static unsigned char valueType2Char( MonitorValueType mvt );

    static MonitorValueType char2ValueType( unsigned char uc );

    tagIDType getTagID( ) const;

    ushort getSampleOffset( ) const;

    ushort getNumSamplesPerCycle( ) const;

    MonitorValueType getValueType( ) const;
    void setValueType( MonitorValueType mvt );
};  // 8 bytes


class MonitorPointHeader {
  public:
    MonitorPointHeader( MonitorHeader &      header,
                        MonitorSampleValue * samples,
                        int                  index = -1,
                        MonitorPointSet *    set = 0 );

    ~MonitorPointHeader( );

    MonitorPointHeader & operator=( const MonitorPointHeader & rhs );


    tagIDType getTagID( ) const;

    ushort getNumSamplesPerCycle( ) const;

    void setNumSamplesPerCycle( const ushort nSamples );

    ushort getSampleOffset( ) const;

    void                setSampleOffset (const ushort sampleOffset)  {  this->header_.sampleOffset = sampleOffset;  }

    void setValueType( MonitorValueType mvt );

    MonitorValueType getValueType( ) const;

    const MonitorSampleValue & getMonitorSampleValueRef( int iSample ) const;
    MonitorSampleValue & getMonitorSampleValueRef( int iSample );

    const MonitorSampleValue & getAverageMonitorSampleValueRef( ) const;
    MonitorSampleValue & getAverageMonitorSampleValueRef( );

    MonitorPointSample getMonitorPointSample( int iSample );


    MonitorPointSample getSampleAverage( );

    void        clearSamples (bool deallocate = false);

    void                setSamplesPerCycle (const ushort nSamples)
        {  this->header_.nSamples = nSamples;  }
  
  private:

    MonitorHeader & header_;

    MonitorSampleValue*        const samples_;

    const int        index_;

    MonitorPointSet * const        set_;
};


} } // namespace monitor, carma


inline unsigned char
carma::monitor::MonitorHeader::valueType2Char( const MonitorValueType mvt )
{
    return static_cast< unsigned char >( mvt );
}


inline carma::monitor::MonitorValueType
carma::monitor::MonitorHeader::char2ValueType( const unsigned char uc )
{
    return static_cast< MonitorValueType >( uc );
}


inline carma::monitor::tagIDType
carma::monitor::MonitorHeader::getTagID( ) const
{
    return tagID;
}


inline ushort
carma::monitor::MonitorHeader::getSampleOffset( ) const
{
    return sampleOffset;
}


inline ushort
carma::monitor::MonitorHeader::getNumSamplesPerCycle( ) const
{
    return nSamples;
}


inline carma::monitor::MonitorValueType
carma::monitor::MonitorHeader::getValueType( ) const
{
    return char2ValueType( type );
}


inline void
carma::monitor::MonitorHeader::setValueType( const MonitorValueType mvt )
{
    type = valueType2Char( mvt );
}


inline
carma::monitor::MonitorPointHeader::MonitorPointHeader(
    MonitorHeader &            header,
    MonitorSampleValue * const samples,
    const int                  index,
    MonitorPointSet * const    set ) :
header_( header ),
samples_( samples ),
index_( index ),
set_( set )
{
}


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


inline carma::monitor::MonitorPointHeader &
carma::monitor::MonitorPointHeader::operator=( const MonitorPointHeader & rhs )
{
    if ( this != &rhs )
        header_ = rhs.header_;

    return *this;
}


inline carma::monitor::tagIDType
carma::monitor::MonitorPointHeader::getTagID( ) const
{
    return header_.tagID;
}


inline ushort
carma::monitor::MonitorPointHeader::getSampleOffset( ) const
{
    return header_.sampleOffset;
}


inline ushort
carma::monitor::MonitorPointHeader::getNumSamplesPerCycle( ) const
{
    return header_.nSamples;
}


inline carma::monitor::MonitorValueType
carma::monitor::MonitorPointHeader::getValueType( ) const
{
    return header_.getValueType();
}


inline void
carma::monitor::MonitorPointHeader::setValueType( const MonitorValueType mvt )
{
    header_.setValueType( mvt );
}


inline const carma::monitor::MonitorSampleValue &
carma::monitor::MonitorPointHeader::getMonitorSampleValueRef(
    const int iSample ) const
{  
    return samples_[ header_.sampleOffset + iSample ];
}


inline carma::monitor::MonitorSampleValue &
carma::monitor::MonitorPointHeader::getMonitorSampleValueRef(
    const int iSample )
{  
    return samples_[ header_.sampleOffset + iSample ];
}


inline const carma::monitor::MonitorSampleValue &
carma::monitor::MonitorPointHeader::getAverageMonitorSampleValueRef( ) const
{  
    return samples_[ header_.sampleOffset ];
}


inline carma::monitor::MonitorSampleValue &
carma::monitor::MonitorPointHeader::getAverageMonitorSampleValueRef( )
{  
    return samples_[ header_.sampleOffset ];
}


inline carma::monitor::MonitorPointSample
carma::monitor::MonitorPointHeader::getMonitorPointSample( const int iSample )
{  
    return MonitorPointSample( samples_[ header_.sampleOffset + iSample ],
                               index_,
                               set_);
}


inline carma::monitor::MonitorPointSample
carma::monitor::MonitorPointHeader::getSampleAverage( )
{  
    return MonitorPointSample( samples_[ header_.sampleOffset ],
                               index_,
                               set_ ); 
}


#endif // CARMA_MONITOR_MONITOR_POINT_HEADER_H