Monitor.h

Go to the documentation of this file.

#ifndef GCP_UTIL_MONITOR_H
#define GCP_UTIL_MONITOR_H

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

#include "gcp/control/code/unix/libmonitor_src/monitor_stream.h"

#include "gcp/util/common/DataType.h"
#include "gcp/util/common/RegDate.h"
#include "gcp/util/common/RegDescription.h"
#include "gcp/util/common/MonitorDataType.h"

namespace gcp {
  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);
      
      gcp::control::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<gcp::util::RegDescription> selectedRegs() {
    return selectedRegs_;
      }

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

      std::vector<gcp::util::MonitorDataType::FormatType> nativeFormats() {
    return nativeFormats_;
      }
      
      double getRegAsDouble(MonitorDataType val, 
                RegAspect aspect);
      
      void run();
      void runTest();

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

      void printArrayMap(bool arcvhivedOnly);
      std::vector<std::string> getArrayMapRegisters(bool archivedOnly);

      ArrayMap* arrayMap() {
    return ms_->arraymap;
      }

    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];
      
      gcp::control::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();
      
    public:
      static double parseDateAndTime(std::string utc);
      
      static MonitorDataType::FormatType parseFormat(std::string format);

    private:
      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 val, MonitorDataType& type);
      
    }; // End class Monitor
    
  } // End namespace util
} // End namespace gcp




#endif // End #ifndef GCP_UTIL_MONITOR_H