MonitorPointSet.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITOR_POINT_SET_h
#define CARMA_MONITOR_MONITOR_POINT_SET_h

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

#include <boost/thread/thread.hpp>
#include <map>

namespace carma  {
  namespace monitor  {

class SubsystemFrame;
class SubsystemFrameBuffer;
class Runnable;


class MonitorPointSet {
  public:
    virtual unsigned int read()  ;

    virtual bool        readNewest()  ;  
                                      
    virtual bool readNewestConditionalCopy();

    virtual ushort        getSubsystemID() const;

    void                markMpAtIndexModified (int index);

    void                markMpWithTagIdModified (const tagIDType tagID);

    virtual void        setNumSamplesPerCycle (int index, const ushort samples);

    SubsystemFrame & getSubsystemFrame () const;

    void                   consolidateStorage();


    static MonitorPointSet&        getMonitorPointSet(long subsystemID,
                                                 long maxMonitorPoints,
                                                 long maxSamples); 


    void        startAutoWriter ();

    void        startAutoWriter (double delay);

    void        stopAutoWriter ();

    bool        autoWriterIsAlive ();

    double        getStartWriteTime () const  {  return this->startWriteTime_;  }

    double        getStartScriberWriteTime () const  
        {  return this->inScriberTime_;  }

    double        getEndWriteTime ()  const {  return this->endWriteTime_;  }

    void installPrewriteMethod( const Runnable & prewriteMethod );

    void removePrewriteMethod( const Runnable & prewriteMethod );

    virtual ~MonitorPointSet();
    
    SubsystemFrameBuffer & getBuffer( ) const;

    virtual void write( bool autoWrite, double autoWriteDelay = 0.0 );
    
    unsigned int getHighWaterMark( MonitorValueType mvt );

  private:
    friend class SystemFrameBuffer;

    MonitorPointSet( const MonitorPointSet & rhs );
    MonitorPointSet & operator=( const MonitorPointSet & rhs );

    explicit MonitorPointSet( ::std::auto_ptr< SubsystemFrame > & frame );

    MonitorPointSet( long subsystemID,
                     long maxMonitorPoints,
                     long maxSamples );


    static MonitorPointUpdate_var  getScriberHandle (const std::string& name);

    static double
    writeToScriber( const SubsystemFrame &   ssFrame,
                    MonitorPointUpdate_var & monUpdater,
                    double                   delay,
                    bool &                   writeSucceeded,
                    const MonitorSampleValues & samples );

    void 
    fillMonSampleValuesHoldingMpModifiedLock( 
                    MonitorSampleValues & samples,
                    const SubsystemFrame & ssFrame,
                    const char * const mpModifiedClone );

    void remergeFailedWriteInfoHoldingWritingLock( );

    const Runnable * prewriteMethod_;

    SubsystemFrameBuffer *            frameBuffer_;
    ::std::auto_ptr< SubsystemFrame > frame_;

    const int                    mpModifiedAllocCount_;
    
    // various memebers which indicates which monitor points have been modified
    // since the last update
    util::PthreadMutex     mpModifiedGuard_;
    bool                   mpModifiedAny_;
    char *                 mpModifiedState_;
    int                    mpModifiedSamplesCount_;

    util::PthreadMutex     writingGuard_;
    char *                 writingMpModifiedState_;

    const ::std::string name_;

    const ::std::string scriberName_;

    MonitorPointUpdate_var monUpdater_;

    static void autoWriterThread( MonitorPointSet & owner, 
                                  const double delayInS ); 

    boost::thread autoWriterThread_;

    // time at which last write began
    double  startWriteTime_;
    // time at which CORBA remote method was invoked in ScriberPublisher
    double  inScriberTime_;
    // time at which last write finished
    double  endWriteTime_;

    // Map to carry high water marks for adding monitor points
    ::std::map< MonitorValueType, unsigned int > typeHighWaterMarks_;
};



} } // namespace monitor, carma

#endif // CARMA_MONITOR_MONITOR_POINT_SET_h