SubsystemFrame.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_SUBSYSTEMFRAME_H
#define CARMA_MONITOR_SUBSYSTEMFRAME_H

#include "carma/util/BaseException.h"
#include "carma/monitor/types.h"
#include "carma/monitor/MonitorPointSample.h"
#include "carma/monitor/MonitorPointHeader.h"
#include "carma/monitor/SubsystemFrameHeader.h"

#include <map>

namespace carma  {
namespace monitor  {


void SetFlag( unsigned short &       flags,
              const unsigned short & mask );
              
void UnsetFlag( unsigned short &       flags,
                const unsigned short & mask );
                
unsigned short GetFlag( const unsigned short & flags,
                        const unsigned short & mask );


struct SubsystemDataPointers;

class  MonitorPointSet;
struct TransportSubsystemFrame;


class SubsystemFrame {

 public:
    static const int MONITOR_POINT_ABSENT = -1;
    
    const SubsystemHeader & getSubsystemHeader() const;

    const SubsystemDataPointers & getSubsystemDataPointers() const;

    long        getFrameCount ()  const ;

    long        setFrameCount (const long frameCount)  ;

    bool        isCurrentFrame () const ;

    static bool mjdIsCurrentFrame( double mjd, double * mjdDelta );

    uchar       getStatusFlags()  const ;

    void        setStatusFlags (uchar status)  ;

    long        getMaxNumMonitorPoints ()  const ;

    long        getMaxNumSamples ()  const ;

    MonitorPointHeader        getHeaderByTagID (const tagIDType tagID) const;

    MonitorPointHeader        getHeaderByIndex (int index) const ;

    int           getIndex (const tagIDType tagID) const;

    tagIDType     getTagID (const int index) const ;

    bool        isValid (const tagIDType tagID) const ;

    ushort getSubsystemID( ) const;

    void        setSubsystemID (ushort subsystemID)  ;

    static ushort numSamplesToAllocate (const ushort nSamplesPerCycle) ;

    static long   maxNumSamplesIncludingAverages (const long maxMonitorPoints, 
                                                      const long maxSamples) ;

    static size_t       sizeFrame (long maxMonitorPoints, long maxSamples);

    static void
    setFrameSize( SubsystemHeader &       frame,
                  SubsystemDataPointers & dataPointers,
                  long                    maxMonitorPoints,
                  long                    maxSamples );

    void syncSubsystemToNewFrameData( );

    static void syncSubsystemToNewFrameData(
        SubsystemHeader &       frame,
        SubsystemDataPointers & dataPointers );

    static long         computeCurrentFrameTime () ;

    long        getNumMonitorPoints()  const ;

    long        getNumMonitorPoints (MonitorValueType type) const;

    long        getNumMonitorSamples (MonitorValueType type) const;

    long        getNumMonitorSamples () const ;

    unsigned int getHighwaterNumMonitorSamples ( MonitorValueType type );

    long        getNumSingleSamplePoints ()  const ;

    long        countNumSingleSamplePoints () const ;

    void        setNumSingleSamplePoints (const long numSingleSamples) ;

    ushort        getNumSamplesPerCycle (const tagIDType tagID) const ;

    ushort        getNumSamplesPerCycle (const int index) const ;

    void        setNumSamplesPerCycle (int index, const ushort samples);

    MonitorPointSample getSampleValue (const tagIDType tagID, 
                                       ushort iSample) const ;

    MonitorPointSample getSampleValue (const int index, ushort iSample) const ;

    bool validSampleValue (const tagIDType tagID, 
                           const MonitorPointSample& value) const ;

    const MonitorPointSample  getSampleAverage (const tagIDType tagID) const ;

    const MonitorPointSample  getSampleAverage (const int index) const ;

    MonitorValueType        getValueType (const tagIDType tagID) const ;

    MonitorValueType        getValueType (const int index) const ;

    void        setLastWriterDelay (double time);

    double      getLastWriterDelay () const ;

    void setLastWriteTime( double mjdTimestamp );
    void setLastWriteTime( );

    double      getLastWriteTime () const ;

    void        setScriberWriteDelay (double writeDelay);

    double      getScriberWriteDelay () const ;


    void setScriberWriteTime( double mjdTimestamp );
    void setScriberWriteTime( );

    double      getScriberWriteTime () const ;

    void setPublishTime( double mjdTimestamp );
    void setPublishTime( );

    double      getPublishTime () const ;

    void setReceiveTime( double mjdTimestamp );
    void setReceiveTime( );

    double      getReceiveTime() const ;

    void        clearAllTimes();

    bool        isPublished () const ;

    void        setPublished () ;

    void        clearPublished () ;

    bool        received () const ;

    void        setReceived () ;

    void        clearReceived () ;

    void        markFramePublished();

    void        markFrameReceived();

    struct AllocMpInfo {
        tagIDType        tagID;
        MonitorValueType valueType;
        ushort           nSamplesPerCycle;
    };

    // Allocates space for new monitor point in the subsystem frame.
    // Returns the offset into the value array for the next new monitor point
    // throw ErrorException when no more space available for monitor points
    void allocateMonitorPoints( const AllocMpInfo * infos,
                                size_t              infosCount,
                                bool markMpsAsModified = true );

    SubsystemFrame( SubsystemHeader &       frame,
                    SubsystemDataPointers & dataPointers,
                    bool                    embeddedInAFullSystem );

    virtual ~SubsystemFrame( );

    void consolidateSamples();

    void writeToTransport( TransportSubsystemFrame & transFrame );

    void writeFromTransportFrame( const TransportSubsystemFrame & transFrame );

    void writeFromPointSet( const MonitorSampleValues & samples );

    void        setNumMonitorPoints (ushort numMonitorPoints)  ;

    void        setNumMonitorSamples (ushort numSamples)  ;

    void        setNumActualSamples (ushort numSamples) ;

    int         getNumActualSamples () const ;

  protected:

    SubsystemFrame( ushort         subsystemID,
                    unsigned short numMonitorPoints,
                    unsigned short numSamples,
                    bool           leakStorage );

    void        clearSamples();

    int         getNumAllocatedSamples () const ;

    // Allocates space for new monitor point values in the subsystem frame.
    ushort      allocateSamples (int headerOffset, ushort sampleOffset, 
                                ushort nSamplesPerCycle = 1);
    void        setMonitorPointSet (MonitorPointSet* set) ;

    void writeSampleValue (const int index, 
                           const MonitorSampleValue& value, ushort iSample);

    int         findMonitorPoint(const tagIDType tagID) const ;
    
    MonitorSampleValue*           getSamples() const ;

    const MonitorHeader & getMonitorHeaderRefByIndex( int index ) const;
    MonitorHeader & getWritableMonitorHeaderRefByIndex( int index ) const;

    friend class MonitorPointSet;

  private:
    // No copying
    SubsystemFrame( const SubsystemFrame & rhs );
    SubsystemFrame & operator=( const SubsystemFrame & rhs );

  protected:
    SubsystemHeader &       frame_;
    SubsystemDataPointers & dataPointers_;

  private:
    const bool        shouldDeallocateStorage_;
    const bool        embeddedInAFullSystem_;
    MonitorPointSet * set_;
    ::std::map< MonitorValueType, unsigned int > highwaterMonitorSamples_;
};


class IllegalMonitorPointExceptionObj 
  : public virtual carma::util::BaseException  {
    public:
        IllegalMonitorPointExceptionObj (const char* mesg, 
                                const char* fileName = __FILE__, 
                                const int lineNum = __LINE__)  ;
        IllegalMonitorPointExceptionObj (std::ostringstream& errStream, 
                                const char* fileName = __FILE__, 
                                const int lineNum = __LINE__) ;
        IllegalMonitorPointExceptionObj (const tagIDType tagID, 
                                const ushort subsystemID,
                                const char* fileName = __FILE__, 
                                const int lineNum = __LINE__) ;
};


inline void
SetFlag( unsigned short &       flags,
         const unsigned short & mask ) {
    flags |= mask;
}


inline void
UnsetFlag( unsigned short &       flags,
           const unsigned short & mask ) {
    flags &= (~mask);
}


inline unsigned short
GetFlag( const unsigned short & flags,
         const unsigned short & mask ) {
    return (flags & mask);
}


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


inline long
carma::monitor::SubsystemFrame::getNumMonitorPoints( ) const
{
    return frame_.numMonitorPoints;
}


inline unsigned short
carma::monitor::SubsystemFrame::getSubsystemID( ) const
{
    return frame_.subsystemID;
}


inline void
carma::monitor::SubsystemFrame::setMonitorPointSet( MonitorPointSet * const s )
{
    set_ = s;
}


inline const carma::monitor::SubsystemHeader &
carma::monitor::SubsystemFrame::getSubsystemHeader( ) const
{
    return frame_;
}


inline const carma::monitor::SubsystemDataPointers &
carma::monitor::SubsystemFrame::getSubsystemDataPointers( ) const
{
    return dataPointers_;
}


inline int
carma::monitor::SubsystemFrame::getNumAllocatedSamples( ) const
{
    return frame_.numSamples;
}


inline const carma::monitor::MonitorHeader &
carma::monitor::SubsystemFrame::getMonitorHeaderRefByIndex(
    const int index ) const
{
    return dataPointers_.monitorHeaders[ index ];
}


inline unsigned short
carma::monitor::SubsystemFrame::getNumSamplesPerCycle( const int index ) const
{
    return getMonitorHeaderRefByIndex( index ).getNumSamplesPerCycle();
}


#endif