MonitorPointSample.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITOR_POINT_SAMPLE_H
#define CARMA_MONITOR_MONITOR_POINT_SAMPLE_H

#include <string>

#include "carma/corba/corba.h"
#include "carma/util/BaseException.h"
#include "carma/monitor/monitorframe.h"
#include "carma/monitor/types.h"

namespace carma {

namespace monitor {

struct TransportMonitorValue;
struct TransportMonitorSample;

typedef union {
    uchar       byte;
    short       sh;
    long        lo;
    bool        bo;
    float       fl;
    double      db;
    float       complex[2];
    char        str[8];
    long        sn;
} MonitorValue; // 8 bytes

struct MonitorSampleValue {
    MonitorValue        value;
    uchar               blankingFlags;
    uchar               validityFlags;
    uchar               iSample;
    uchar               dummy;

    uchar getValidityFlags( ) const;
    uchar getBlankingFlags( ) const;
}; // 12 bytes


struct MonitorValueStringChunk {
    char chunkChars[8];
};


class MonitorPointSet;

class MonitorPointSample {
  public:
    explicit MonitorPointSample( MonitorSampleValue & sample,
                                 int                  index = -1,
                                 MonitorPointSet *    set = 0 );

    ~MonitorPointSample( );

    MonitorValue & getMonitorValue () const;

    void setMonitorValueAndKnownSaneValidityFlags( char  value,
                                                   uchar saneFlags );
    void setMonitorValueAndKnownSaneValidityFlags( short value,
                                                   uchar saneFlags );

    void setMonitorValueAndKnownSaneValidityFlags( long  value,
                                                   uchar saneFlags );

    void setMonitorValueAndKnownSaneValidityFlags( bool  value,
                                                   uchar saneFlags );

    void setMonitorValueAndKnownSaneValidityFlags( float value,
                                                   uchar saneFlags );

    void setMonitorValueAndKnownSaneValidityFlags( double value,
                                                   uchar  saneFlags );

    void setMonitorValueAndKnownSaneValidityFlags( const float value[2],
                                                   uchar       saneFlags );

    void setValueStringChunkAndKnownSaneValidityFlags(
        const MonitorValueStringChunk & value,
        uchar                           saneFlags );

    void setValueSerialNoAndKnownSaneValidityFlags( long  value,
                                                    uchar saneFlags );

    uchar getBlankingFlags( ) const;

    void setBlankingFlags( uchar flags );

    void clearBlankingFlags( );

    ushort getSampleNumber( ) const;

    void setSampleNumber( ushort iSample );

    uchar getValidityFlags( ) const ;

    void setValidityFlags( uchar flags );

    void setKnownSaneValidityFlags( uchar saneFlags, 
                                    bool markMpAsModified = true );

    void        clearValidityFlags ();

    void        clearFlags ();

    MonitorPointSample & operator=( const MonitorPointSample & rhs );

    void        allocate (ushort headerOffset, ushort iSample);

    void                clear (bool deallocate = false);

    MonitorSampleValue & getSample( ) const;

    void fillInTransportSample( CORBA::ULong                    metaIdx,
                                MonitorSampleValues &    outSamples,
                                MonitorValueType                mvt,
                                tagIDType                       tagId,
                                int                             sampleIndex ) const;
    void getTransportedSample( CORBA::ULong metaIdx,
                               const MonitorSampleValues & inValues,
                               int                            headerOffset );

    void setTransportValue(MonitorValueType       valueType,
                           TransportMonitorValue& value ) const;
                           
  protected:
    MonitorValue & getValue( ) const;

  private:
    void setMonitorValueAndKnownSaneValidityFlags(
        const MonitorValue & value,
        uchar                saneFlags );

    void getTransportedValue( MonitorValueType              valueType,
                              const TransportMonitorValue & value );


    // MonitorSampleValue structure in subsystem frame container.
    MonitorSampleValue & sample_;

    // index to monitor point header in containing subsystem frame
    const int index_;

    // pointer to containing MonitorPointSet
    MonitorPointSet * const set_;
};



class SampleInvalidExceptionObj : public virtual carma::util::BaseException  {
    public:
        explicit SampleInvalidExceptionObj(
            const char * mesg,
            const char * fileName = __FILE__,
            int          lineNum = __LINE__ );

        explicit SampleInvalidExceptionObj(
            const std::ostringstream & errStream,
            const char *               fileName = __FILE__,
            int                        lineNum = __LINE__ );

        SampleInvalidExceptionObj(
            const MonitorSampleValue & sample,
            MonitorValueType           type,
            const char *               fileName = __FILE__,
            int                        lineNum = __LINE__ );

        SampleInvalidExceptionObj(
            const MonitorPointSample & sample,
            MonitorValueType           type,
            const char *               fileName = __FILE__,
            int                        lineNum = __LINE__ );
};

} } // namespace monitor, carma


inline carma::monitor::uchar
carma::monitor::MonitorSampleValue::getValidityFlags( ) const
{
    return validityFlags;
}


inline carma::monitor::uchar
carma::monitor::MonitorSampleValue::getBlankingFlags( ) const
{
    return blankingFlags;
}


inline
carma::monitor::MonitorPointSample::MonitorPointSample(
    MonitorSampleValue &    sample,
    const int               index,
    MonitorPointSet * const set ) :
sample_( sample ),
index_( index ),
set_( set )
{
}


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


inline carma::monitor::MonitorPointSample &
carma::monitor::MonitorPointSample::operator=( const MonitorPointSample & rhs )
{
    if ( this != &rhs ) {
        sample_.value         = rhs.sample_.value;
        sample_.blankingFlags = rhs.sample_.blankingFlags;
        sample_.validityFlags = rhs.sample_.validityFlags;
    }

    return *this;
}


inline carma::monitor::MonitorValue &
carma::monitor::MonitorPointSample::getMonitorValue( ) const
{
    return sample_.value;
}


inline carma::monitor::uchar
carma::monitor::MonitorPointSample::getValidityFlags( ) const
{
    return sample_.validityFlags;
}


inline carma::monitor::uchar
carma::monitor::MonitorPointSample::getBlankingFlags( ) const
{
    return sample_.blankingFlags;
}


inline unsigned short
carma::monitor::MonitorPointSample::getSampleNumber( ) const
{
    return sample_.iSample;
}


inline void
carma::monitor::MonitorPointSample::setSampleNumber( const ushort iSample )
{
    sample_.iSample = iSample;
}


inline carma::monitor::MonitorSampleValue &
carma::monitor::MonitorPointSample::getSample( ) const
{
    return sample_;
}


inline carma::monitor::MonitorValue &
carma::monitor::MonitorPointSample::getValue( ) const
{
    return sample_.value;
}


inline void
carma::monitor::MonitorPointSample::setBlankingFlags( const uchar flags )
{
    sample_.blankingFlags = flags;
}


inline void
carma::monitor::MonitorPointSample::clearBlankingFlags( )
{
    sample_.blankingFlags = 0;
}


inline void
carma::monitor::MonitorPointSample::clearValidityFlags( )
{
    sample_.validityFlags = 0;
}


inline void
carma::monitor::MonitorPointSample::clearFlags( )
{
    sample_.blankingFlags = 0;
    sample_.validityFlags = 0;
}


inline void
carma::monitor::MonitorPointSample::clear( const bool deallocate )
{
    sample_.blankingFlags = 0;
    sample_.validityFlags = 0;

    if ( deallocate ) {
        sample_.dummy = 0;
        sample_.iSample = 0;
    }
}


inline void
carma::monitor::MonitorPointSample::allocate( const ushort headerOffset,
                                              const ushort iSample )
{
    sample_.blankingFlags = 0;
    sample_.validityFlags = 0;
    sample_.dummy = (headerOffset & 0x00FF);
    sample_.iSample = iSample;
}


#endif // CARMA_MONITOR_MONITOR_POINT_SAMPLE_H