SystemFrame.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_SYSTEMFRAME_H
#define CARMA_MONITOR_SYSTEMFRAME_H

#include <memory>
#include "carma/util/PthreadRWLock.h"

namespace carma  {
namespace monitor  {


struct TransportSubsystemFrame;
struct SubsystemHeader;
struct SubsystemDataPointers;
class SubsystemFrame;


class SystemFrame {
  public:
    virtual ~SystemFrame( );

    void synchronize( const SystemFrame & src );

    bool isCurrentFrame( ) const;

    // callers responsibility to delete memory
    ::std::auto_ptr< SubsystemFrame >
    makeSubsystemFrame( unsigned short subsystemID ) const;

    ::std::auto_ptr< SubsystemFrame >
    makeSubsystemFrameForIndex( int index ) const;

    bool        isCurrent (unsigned short subsystemID) const ;

    long        getFrameCount ()  const ;

    long        setFrameCount (const long frameCount)  ;

    bool        isComplete ()  const ;

    void writeSubsystemFrame (
        const TransportSubsystemFrame & subsystemFrame );

    long        getMaxNumSubsystemFrames ()  const ;

    long        getMaxTotalMonitorPoints ()  const ;

    long        getMaxTotalSamples ()  const ;

    long        getNumSubsystemFrames () const ;

    void        setNumSubsystemFrames (unsigned short numSubsystems) ;

    void        setCollatorWriteDelay (double writeDelay);

    double getCollatorWriteDelay () const;

    void setCollatorWriteTime( double mjdTimestamp );
    //void setCollatorWriteTime( );

    double getCollatorWriteTime () const;

    void setRawReadTime ( double mjdTimestamp );
    //void setRawReadTime( );

    double getRawReadTime () const;

    void setFinalWriteTime( double mjdTimestamp );
    //void setFinalWriteTime( );

    double getFinalWriteTime () const;

    void        clearAllTimes();

    unsigned char getStatusFlags ()  const ;

    void        setStatusFlags (unsigned char flags)  ;

    bool subsystemFrameIsWritten( unsigned short subsystemID ) const;

    int allocateSubsystemFrame( unsigned short subsystemID, 
                                long           ssMaxMonitorPoints,
                                long           ssMaxSamples );

    void        resetNumCleanFrames() ;

    static size_t getSystemHeaderSizeInBytes( );
    
    size_t getSystemTotalSizeInBytes( ) const;

  protected:
    static const int SUBSYSTEM_FRAME_ABSENT;

    struct SystemHeader;

    SystemFrame( long maxSubsystems, 
                 long maxMonitorPoints, 
                 long maxSamples );

    SystemHeader & getSystemFrameDataHoldingWriteLock( );
    const SystemHeader & getSystemFrameDataHoldingLock( ) const;

    ::std::auto_ptr< SubsystemFrame >
    makeSubsystemFrameForIndexHoldingLock( int index ) const;

    int
    allocateSubsystemHoldingWriteLock( unsigned short subsystemID, 
                                       long           ssMaxMonitorPoints,
                                       long           ssMaxSamples );

    bool checkIsCurrentFrameHoldingLock( double * mjdDelta ) const;

    int getSubsystemIndexHoldingLock( unsigned short subsystemID ) const;

    void syncSystemAndSubsystemsToNewFrameDataHoldingWriteLock( );

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

    class SsDataPointersManager;

    SubsystemHeader &
    getSubsystemFrameStructHoldingLock( int index ) const;

    void indexInsertKeyHoldingWriteLock( unsigned short subsystemID,
                                         int            newIndex );

    size_t getNextFreeSubsystemFrameHoldingLock( );

    static size_t getSystemFrameStorageSizeInBytes( long maxSubsystems,
                                                    long maxMonitorPoints,
                                                    long maxSamples );

  protected:
    const long   maxSubsystems_;
    const long   maxMonitorPoints_;
    const long   maxSamples_;
    const size_t frameStorageSizeInBytes_;

    mutable util::PthreadRWLock guard_;

    const int *    frameDataSsIndexArray_;
    const size_t * frameDataSsDataOffsetArray_;

  private:
    void * frameStorage_;

    int *    writableFrameDataSsIndexArray_;
    size_t * writableFrameDataSsDataOffsetArray_;

    SsDataPointersManager * ssDataPointersManager_;

    int    numCleanSubsystemFrames_;
    size_t nextFreeSubsystemFrame_;
};


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


#endif