CatchData.h

#ifndef CARMA_PIPELINE_CATCHDATA_H
#define CARMA_PIPELINE_CATCHDATA_H

#include "carma/pipeline/DataContainer.h"
#include "carma/pipeline/pipelineUtils.h"
#include "carma/util/FrameAlignedTimer.h"
#include "carma/util/types.h"

#include <list>
#include <memory>
#include <string>
#include <vector>
#include <pthread.h>

namespace carma {

  namespace corba {
    class Server;
  }

  namespace correlator {
    namespace lib {
      class CorrelatorListener;
      class CorrelatorData;
    }
  }

  namespace monitor {
    class PipelineSubsystem;
  }


  namespace pipeline {
       
      class DataContainer;
      class DataCollectorN;

      class CatchData {
      public:    

        explicit CatchData( PipelineType pt, 
                            long monitorWriteDelayMs, 
                            int corrDataWriteDelayMs,
                            const std::string & channelPrefix,
                            const std::string & channelSuffix,
                            carma::corba::Server & server );

        virtual ~CatchData();

        void addCorrelatorListener(carma::correlator::lib::CorrelatorListener* cListener);

        void run();

      private:
        
        // Disallow copy and assignment
        CatchData( const CatchData & rhs );
        CatchData & operator=( const CatchData & rhs );
        
        struct CorrelatorDataStatsInfo;
        struct SharedMonitorInfo;

        void performUpdate( bool     firstTime,
                            size_t * numBandsHighWaterMark,
                            carma::util::frameType frame );
        
        static void harvestCorrelatorDataStatsInfo(
            CorrelatorDataStatsInfo *                      cdsi,
            const carma::correlator::lib::CorrelatorData & cd );
        
        static void monitorUpdateThread( CatchData & This );

        class MonitorUpdateTQRH; // Thread quit request handler 
        
        void notifyListeners(
            carma::correlator::lib::CorrelatorData * cd ) const;
            
        void processMonitorPoints( const CorrelatorDataStatsInfo & cdsi );
        void fillMonitorData( ) const;
        void computeStats( const CorrelatorDataStatsInfo & cdsi );

        const PipelineType pt_;
        const int waitTimeInMillis_;

        carma::pipeline::DataContainer _dataContainer;
        ::std::list<carma::correlator::lib::CorrelatorListener *> _listeners;

        mutable std::auto_ptr< carma::monitor::PipelineSubsystem > monitorData_;
        ::std::vector< DataCollectorN * > collectors_;

        ::std::auto_ptr< SharedMonitorInfo > smi_;
        mutable carma::util::PthreadMutex smiMutex_;

        carma::util::FrameAlignedTimer frameTimer_;
        ::pthread_t monitorUpdateThread_;
      };

}  // End namespace pipeline
}  // End namespace carma

#endif