Monitor.h

Go to the documentation of this file.

#ifndef SZA_UTIL_MONITOR_H
#define SZA_UTIL_MONITOR_H

#include <map>
#include <string>
#include <vector>

#include "carma/szaarrayutils/monitor_stream.h"

#include "carma/szautil/DataType.h"
#include "carma/szautil/RegDate.h"
#include "carma/szautil/RegDescription.h"
#include "carma/szautil/MonitorDataType.h"

namespace sza {
  namespace util {
    
    class Monitor {
    public:
      
      Monitor(std::string arcDir, std::string calFile, std::string host,
              std::string start, bool startWasSet, 
              std::string stop,  bool stopWasSet,
              std::string regFile);
      
      Monitor(std::string arcDir, std::string calFile,
              std::string startMjd, std::string stopMjd);
      
      Monitor(std::string host, std::string calFile);

      virtual ~Monitor();
      
      void addRegister(std::string regmapName, 
                       std::string boardName, 
                       std::string regname, 
                       RegAspect aspect=REG_PLAIN, 
                       MonitorDataType::FormatType=MonitorDataType::FM_UNKNOWN, 
                       char* formatString=0,
                       MonitorDataType::FormatType=MonitorDataType::FM_UNKNOWN, 
                       CoordRange* range=0);

      void addRegister(std::string regSpec);

      sza::array::MsReadState readNextFrame();

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       unsigned* data, CoordRange* range);

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       int* data, CoordRange* range);

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       unsigned long* data, CoordRange* range);

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       long* data, CoordRange* range);

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       float* data, CoordRange* range);

      void getRegister(std::string regmapName, std::string boardName, 
                       std::string regname,
                       double* data, CoordRange* range);

      void printDoubleRegs();
      void printUnsignedIntRegs();

      void readRegs();

      unsigned countFrames();

      std::vector<std::vector<double> > readRegsAsDoubles();
      std::vector<std::vector<std::vector<MonitorDataType> > > readRegsAsDataTypes();

      void printRegs();
      void printRegs2();

      std::vector<double> getRegsAsDoubles();
      std::vector<std::vector<MonitorDataType> > getRegsAsDataTypes();
      
      std::vector<sza::util::RegDescription> selectedRegs() {
        return selectedRegs_;
      }

      std::vector<sza::util::MonitorDataType::FormatType> selectedFormats() {
        return selectedFormats_;
      }

      std::vector<sza::util::MonitorDataType::FormatType> nativeFormats() {
        return nativeFormats_;
      }

      double getRegAsDouble(MonitorDataType val, 
                            RegAspect aspect);

      void run();
      void runTest();

      double* getCalSlotPtr(unsigned iSlot=0);
        
      void reinitialize();

    private:

      enum KeywordType {
        ADD_REGISTER,
        READ,
        UNKNOWN
      };

      struct Keyword {
        std::string keyword;
        KeywordType type;
      };

      static Keyword keywords[];
      static int nKey_;

      struct Format {
        std::string format;
        MonitorDataType::FormatType type;
      };

      static Monitor::Format formats[];
      static int nFormat_;

      enum StreamType {
        MS_FILE = 0x1,
        MS_NET  = 0x2,
        MS_BOTH = MS_FILE | MS_NET
      };

      Monitor::StreamType type_;

      OutputStream* outputStream_;
      char fmtString_[100];

      sza::array::MonitorStream* ms_;

      std::map<std::string, std::map<std::string, std::map<std::string, RegDescription* > > > regMap_;

      std::map<std::string, std::map<std::string, std::map<std::string, MonitorDataType::FormatType > > > regSelFormat_;

      std::map<std::string, std::map<std::string, std::map<std::string, MonitorDataType::FormatType > > > regNatFormat_;

      std::map<std::string, std::map<std::string, std::map<std::string, RegAspect > > > regAspect_;

      std::vector<RegDescription> selectedRegs_;
      std::vector<RegAxisRange> regAxisRanges_;
      std::vector<RegAspect> aspects_;
      std::vector<MonitorDataType::FormatType> selectedFormats_;
      std::vector<MonitorDataType::FormatType> nativeFormats_;
      std::vector<MonitorSelection> selections_;
      std::vector<std::string> formatStrings_;
      std::vector<bool> hasFormatString_;

      std::string calFile_;
      std::string host_;
      std::string regFile_;
      bool readRegSpecFromFile_;

      bool initialized_;

      bool hybrid_;

      void privateConstructor(std::string arcDir, std::string calFile, 
                              std::string host,
                              std::string start, bool startWasSet, 
                              std::string stop,  bool stopWasSet,
                              std::string regFile);
      
      void setMonitoringInterval(unsigned interval);

      void sendMonitoringInterval();

      void sendRegisterSelection();

      void loadCalFile();

      void changeMonitorStream();

      double parseDateAndTime(std::string utc);

      KeywordType readKeyword(InputStream* stream);

      MonitorDataType::FormatType readFormat(InputStream* stream);
      char* readFormatString(InputStream* stream);

      void skipToNextLine(InputStream* stream);

      void addRegister(RegDescription& desc, MonitorDataType::FormatType format, 
                       char* formatString);

      void addRegisters(std::vector<RegDescription>& regs, 
                        MonitorDataType::FormatType format,
                        char* formatString);

      void addRegister(InputStream* stream);

      void getRegister(RegDescription* desc,
                       MonitorDataType* data, CoordRange* range);

      void getSingleRegisterVal(RegDescription* desc,
                                MonitorDataType* data, CoordRange* range);

      void getRegisterVals(std::vector<MonitorDataType>& data,
                           RegDescription* desc, 
                           MonitorDataType* val,
                           RegAxisRange& regAxisRange);

    public:
      static MonitorDataType::FormatType 
        formatOf(RegDescription& reg, 
                 MonitorDataType::FormatType format=MonitorDataType::FM_UNKNOWN);


    private:
      std::string formatStringOf(MonitorDataType::FormatType format,
                                 RegAspect aspect);

      void outputReg(MonitorDataType val, RegAspect aspect, char* formatPtr);
      MonitorDataType formatReg(MonitorDataType val, RegAspect aspect, std::string& formatStr);

      void formatRegs(std::vector<MonitorDataType>& vals, 
                      MonitorDataType& val,
                      RegAspect aspect, std::string& formatStr);

      void convertDateToType(MonitorDataType& val);
      
      void convertComplexFloatToType(MonitorDataType& val, RegAspect aspect);

      void doubleToType(double dVal, MonitorDataType& val);

    }; // End class Monitor
    
  } // End namespace util
} // End namespace sza



#endif // End #ifndef SZA_UTIL_MONITOR_H