MonitorPointManager.h

#ifndef GCP_UTIL_MONITORPOINTMANAGER_H
#define GCP_UTIL_MONITORPOINTMANAGER_H

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

#include "gcp/control/code/unix/libunix_src/common/regmap.h"

namespace gcp {
  namespace util {
    
    class ArrayMapDataFrameManager;
    class CoordRange;
    class MonitorPoint;
    class RegMapDataFrameManager;
    
    class MonitorPointManager {
    public:
      
      MonitorPointManager();
      MonitorPointManager(ArrayMapDataFrameManager* arrMapFm);
      MonitorPointManager(RegMapDataFrameManager*   regMapFm);
      
      virtual ~MonitorPointManager();
      
      MonitorPoint* addMonitorPoint(char* regMapName, char* boardName, 
                    char* blockName, 
                    CoordRange* range=0);

      MonitorPoint* addMonitorPoint(std::string regMapName, 
                    std::string boardName, 
                    std::string blockName, 
                    CoordRange* range=0);

      MonitorPoint* addMonitorPoint(char* regMapName, char* boardName, 
                    char* blockName, 
                    int   index);
      
      MonitorPoint* addMonitorPoint(char* boardName,  char* blockName, 
                    CoordRange* range=0);

      MonitorPoint* addMonitorPoint(char* boardName,  char* blockName, 
                    int   index);
      
      MonitorPoint* findMonitorPoint(char* boardName, char* blockName, 
                     CoordRange* range=0, bool doThrow=true);

      MonitorPoint* findMonitorPoint(char* regMapName, char* boardName, 
                     char* blockName, 
                     CoordRange* range=0, bool doThrow=true);

      MonitorPoint* findMonitorPoint(std::string boardName, 
                     std::string blockName, 
                     CoordRange* range=0, bool doThrow=true);

      MonitorPoint* findMonitorPoint(std::string regMapName, 
                     std::string boardName, 
                     std::string blockName, 
                     CoordRange* range=0, bool doThrow=true);
      

      // Remove a single monitor point maintained by this object

      void remMonitorPoint(std::string regMapName, 
               std::string boardName, 
               std::string blockName, 
               CoordRange* range=0);
      
      void remMonitorPoint(std::string boardName, 
               std::string blockName, 
               CoordRange* range=0);
      
      void remMonitorPoint(std::ostringstream& os);
      
      // Reset all monitor points managed by this object
      
      void reset();

      // Clear all monitor points managed by this object

      void clear();

      // List monitor points managed by this object

      void list();

      // Return a list of all monitor points

      std::vector<std::string> getList(bool sort=false);

      friend std::ostream& operator<<(std::ostream& os, 
                      MonitorPointManager& mp);

      // Return a formatted printout of a single monitor point

      std::string formatReg(std::string regMapName, std::string boardName, std::string blockName, 
                CoordRange* range);

      RegMapBlock* findReg(std::string regmap, std::string board, std::string block);

    private:
      
      bool isArrMap_;
      RegMapDataFrameManager* regMapFm_;
      ArrayMapDataFrameManager* arrMapFm_;

      std::vector<MonitorPoint*> monitorPoints_;
      std::map<std::string, MonitorPoint*> monitorMap_;
      
    }; // End class Monitor
    
  } // End namespace util
} // End namespace gcp



#endif // End #ifndef GCP_UTIL_MONITORPOINTMANAGER_H