CtrlInfo.h

// -*- c++ -*-

#ifndef __CTRLINFO_H__
#define __CTRLINFO_H__

#include <stdio.h>
#include <string>

#include "tools/MemoryBuffer.h"
#include "storage/StorageTypes.h"


class NumericInfo
{
public:

    float    disp_high;  
    float    disp_low;   
    float    low_warn;   
    float    low_alarm;  
    float    high_warn;  
    float    high_alarm; 
 
    int32_t  prec;       
    char     units[1];   

};

class EnumeratedInfo
{
public:

  int16_t num_states;       
  int16_t pad;              
  char    state_strings[1]; 

};

class CtrlInfoData {
public:

  uint16_t  size; 
  uint16_t  type; 

  union {
        NumericInfo     analog;
        EnumeratedInfo  index;
  } value; 

    // class will be as long as necessary
    // to hold the units or all the state_strings
};

class CtrlInfo {
public:

  CtrlInfo();

  CtrlInfo(const CtrlInfo& rhs);
    
  CtrlInfo& operator = (const CtrlInfo& rhs);

  bool operator == (const CtrlInfo& rhs) const;
    
  bool operator != (const CtrlInfo& rhs) const
    {   return ! (*this == rhs);    }

  typedef enum {
        Invalid = 0,   
        Numeric = 1,   
        Enumerated = 2 
  } Type;

    Type getType() const;

    // Read Control Information:
    // Numeric precision, units,
    // high/low limits for display etc.:

    int32_t getPrecision() const;

    const char* getUnits() const;

    float getDisplayHigh() const;

    float getDisplayLow() const;

    float getHighAlarm() const;

    float getHighWarning() const;

    float getLowWarning() const;

    float getLowAlarm() const;

    void setNumeric(int32_t prec, const std::string& units,
                    float disp_low, float disp_high,
                    float low_alarm, float low_warn,
                    float high_warn, float high_alarm);

    void setEnumerated(size_t num_states, char *strings[]);

    void allocEnumerated(size_t num_states, size_t string_len);

    void setEnumeratedString(size_t state, const char *string);

    void calcEnumeratedSize();

    void formatDouble(double value, std::string& result) const;

    size_t getNumStates() const;
    
    void getState(size_t state, std::string& result) const;

    bool parseState(const char *text, const char **next, size_t &state) const;

    //    void read(class DataFile *datafile, FileOffset offset);

    //    void write(class DataFile *datafile, FileOffset offset) const;

    void show(FILE *f) const;

    size_t getSize() const
    {   return _infobuf.mem()->size; }

  const MemoryBuffer<CtrlInfoData>& getMemoryBuffer() const {
    return  _infobuf;
  }

  MemoryBuffer<CtrlInfoData>& getMemoryBuffer() {
    return  _infobuf;
  }
    
protected:

    const char *getState(size_t state, size_t &len) const;

    MemoryBuffer<CtrlInfoData>  _infobuf;
};


 
#endif