MonitorDescription.h

#ifndef CARMA_DBMS_MONITORDESCRIPTION_H
#define CARMA_DBMS_MONITORDESCRIPTION_H

#include <string>
#include <map>

#include "carma/corba/corba.h"
#include "carma/dbms/MonitorSystemAndDBMSRelationships.h"
#include "carma/monitor/types.h"
#include "carma/util/Time.h"


namespace carma {
  namespace dbms {


    class MonitorDescription {
    public:
      
      MonitorDescription(const std::string& canonicalName, 
                         const MonitorPointType& mpType, 
                         const MonitorPointDataType& dataType, 
                         const bool& persistent, const unsigned& updateInterval,
                         const bool& spectrum);

      virtual ~MonitorDescription() {}

      inline void setShortName(const std::string& shortName) {
          shortName_ = shortName; 
      }

      inline void setLongName(const std::string& longName) {
          longName_ = longName;
      }

      inline void setUnits(const std::string& units) { units_ = units; }

      inline void setDescription(const std::string& description) {
          description_ = description;
      }

      /*
      inline void setIntegrateFunction(const std::string& integrateFunction) {
          integrateFunction_ = integrateFunction;
      }
      */

      inline void setTime(const carma::util::frameType& frameCount) {
          time_ = frameCount;
      }


      /*
      void setWarnLo(const char* warnLo);
      void setWarnHi(const char* warnHi);
      void setWarnHi(const float& warnHi);
      void setErrLo(const char* errLo);
      void setErrLo(const float& errLo);
      void setErrHi(const char* errHi);
      void setErrHi(const float& errHi);
      */

      void setThresholdValue
          (const carma::monitor::ThresholdValueEnum& thresholdType,
           const double& value);

      double getThresholdValue
          (const carma::monitor::ThresholdValueEnum& thresholdType) const;

      bool isDefaultThresholdValue
          (const carma::monitor::ThresholdValueEnum& thresholdType) const;
      
      double getThresholdDefaultValue
          (const carma::monitor::ThresholdValueEnum& thresholdType) const;


      inline std::string getSubsystemName() const {
          return subsystemName_;
      }

      inline std::string getName() const { return cname_;}
      
      std::string getShortName() const { return shortName_; }

      inline std::string getLongName() const { return longName_; }

      inline std::string getUnits() const { return units_; }

      inline int getUpdateInterval() const { return updateInterval_; }

      inline std::string getDescription() const {
          return description_;
      }

      inline MonitorPointType getMonitorPointType() const {
          return monitorPointType_;
      }

      inline MonitorPointDataType getDataType() const { return dataType_; }

      inline bool isPersistent() const { return persistent_; }

      inline bool isSpectrum() const { return spectrum_; }


      inline std::string getIntegrateFunction() const { 
          return integrateFunction_; 
      }

      inline carma::util::frameType getTime() const {
          return time_;
      }

      std::string toString() const;

      bool isEqualExceptForTime(const MonitorDescription& md) const;

      void addEnumerator(const std::string& enumerator, 
                         const std::string& description = "");

      void setEnumeratorDescription(const std::string& enumerator, 
                         const std::string& description = "");

      std::vector<std::string> getEnumerators() const;

      std::map<std::string,std::string> getEnumeratorDescriptions() const;

      inline void setLocation(const std::string& location) { 
          location_ = location; 
      }

      inline std::string getLocation() const { return location_; }

      inline void setDevice(const std::string& device) { device_ = device; }

      inline std::string getDevice() const { return device_; }

      bool areStaticFieldsEqual(const MonitorDescription& other, 
                                std::string& msg) const;

      void makeStaticChangedString(std::ostringstream &ss,
                                   const std::string &fieldName,
                                   const std::string &oldValue,
                                   const std::string &newValue)const;

      void makeStaticChangedString(std::ostringstream &ss,
                                   const char *fieldName,
                                   const std::string &oldValue,
                                   const std::string &newValue)const;

#if 0

      MonitorDescription MonitorDescription::makeCopy(
                const std::string &canonicalName, 
                carma::util::frameType time=0)const;
#endif

private:

      MonitorPointType monitorPointType_; // type of monitor point
      
      // canonical name of the point
      std::string cname_;  
      std::string subsystemName_;  // subsystem name 

      MonitorPointDataType dataType_;

      // location and device name for the point. Only matters for sense points
      std::string location_;
      std::string device_;


      int updateInterval_;
      bool persistent_;
      bool spectrum_;
      
      /* elements of a monitor point */
      // brief name to use as part of compact display
      std::string shortName_; 
      // longer name/statement suitable for tooltip display
      std::string longName_;  
      // measurement units for values of this point
      std::string units_; 

      // full description
      std::string description_; 

      // name of fctn to use to integrate point over some time interval
      std::string integrateFunction_; 
      
      //time at which the description became valid
      carma::util::frameType time_;

      // for points of type DATATYPE_ENUMERATION, this is where the enumerator 
      // values are held, it maps enumerator values to their descriptions
      std::vector<std::string> enumeratorNames_;
      std::map<std::string,std::string> enumeratorDescriptions_;
      

      /* warnings/errors are ignored unless point is a numeric type */
      
      /*
       * the default values of the thresholds are stored as NULLs in the
       * database.  This class converts to a default double based on
       * the monitor point type.  to know if the value in the db is null,
       * use the isDefaultThreshold() method.
       */

      double warnLo_; 
      double warnHi_; 
      double errLo_;  
      double errHi_;  

      bool isDefaultWarnLo_;
      bool isDefaultWarnHi_;
      bool isDefaultErrLo_;
      bool isDefaultErrHi_;

    }; // end class
  }; // end namespace dbms
}; // end namespace carma

#endif