Record.hpp

Go to the documentation of this file.

#ifndef IFW_DIT_DID_RECORD_HPP_
#define IFW_DIT_DID_RECORD_HPP_

#include <string>

#include "ctd/defines/defines.hpp"
#include "ctd/file/Yaml.hpp"


namespace dit {
  namespace did {

    class Range {
    public:
      Range();

      Range(ctd::defines::DataType data_type,
            const std::string& lower_limit,
            const std::string& upper_limit);

      Range(const Range& source);

      ~Range();

      void SetLimits(ctd::defines::DataType data_type,
                     const std::string& lower_limit,
                     const std::string& upper_limit);

      template <class TYPE>
      void GetLowerLimit(TYPE& lower_limit) const {
        RAD_LOG_TRACE();

        lower_limit = ctd::conversion::Convert(m_lower_limit, m_data_type, lower_limit);
      }

      template <class TYPE>
      void GetUpperLimit(TYPE& upper_limit) const {
        RAD_LOG_TRACE();

        upper_limit = ctd::conversion::Convert(m_upper_limit, m_data_type, upper_limit);
      }

      std::string ToString() const;

      Range& operator = (const Range& source);

    protected:
      ctd::defines::DataType m_data_type;
      std::string            m_lower_limit;
      std::string            m_upper_limit;

    private:
      void _Copy(const Range& source);
    };


    class FormatSpecifier {
    public:

      FormatSpecifier() {
        Reset();
      };

      ~FormatSpecifier() {};

      void Reset() {
        m_flag = 0;
        m_width = 0;
        m_precision = 0;
        m_length = "";
        m_specifier = 0;
      };

      char        m_flag {0};
      int8_t      m_width {0};
      int8_t      m_precision {0};
      std::string m_length;
      char        m_specifier {0};
    };

    typedef enum {
      DID_REC_FIELD_CLASS       =   2,
      DID_REC_FIELD_TYPE        =   4,
      DID_REC_FIELD_FORMAT      =   8,
      DID_REC_FIELD_DEFAULT     =  16,
      DID_REC_FIELD_UNIT        =  32,
      DID_REC_FIELD_RANGE       =  64,
      DID_REC_FIELD_COMMENT     = 128,
      DID_REC_FIELD_TAGS        = 256,
      DID_REC_FIELD_DESCRIPTION = 512,

      DID_REC_FIELD_ALL         = (DID_REC_FIELD_CLASS | DID_REC_FIELD_TYPE |
      DID_REC_FIELD_FORMAT | DID_REC_FIELD_DEFAULT | DID_REC_FIELD_UNIT |
      DID_REC_FIELD_RANGE | DID_REC_FIELD_COMMENT | DID_REC_FIELD_TAGS |
      DID_REC_FIELD_DESCRIPTION)

    } DidRecField;

    // Dictionary Record Fields.
    const std::string DID_REC_FIELD_CLASS_STR       = "Class";
    const std::string DID_REC_FIELD_TYPE_STR        = "Type";
    const std::string DID_REC_FIELD_FORMAT_STR      = "Format";
    const std::string DID_REC_FIELD_DEFAULT_STR     = "Default";
    const std::string DID_REC_FIELD_UNIT_STR        = "Unit";
    const std::string DID_REC_FIELD_RANGE_STR       = "Range";
    const std::string DID_REC_FIELD_COMMENT_STR     = "Comment";
    const std::string DID_REC_FIELD_TAGS_STR        = "Tags";
    const std::string DID_REC_FIELD_DESCRIPTION_STR = "Description";

     const std::map<DidRecField, std::string> DID_REC_FIELDS_NB_MAP = {
      {DID_REC_FIELD_CLASS,       DID_REC_FIELD_CLASS_STR},
      {DID_REC_FIELD_TYPE,        DID_REC_FIELD_TYPE_STR},
      {DID_REC_FIELD_FORMAT,      DID_REC_FIELD_FORMAT_STR},
      {DID_REC_FIELD_DEFAULT,     DID_REC_FIELD_DEFAULT_STR},
      {DID_REC_FIELD_UNIT,        DID_REC_FIELD_UNIT_STR},
      {DID_REC_FIELD_RANGE,       DID_REC_FIELD_RANGE_STR},
      {DID_REC_FIELD_COMMENT,     DID_REC_FIELD_COMMENT_STR},
      {DID_REC_FIELD_TAGS,        DID_REC_FIELD_TAGS_STR},
      {DID_REC_FIELD_DESCRIPTION, DID_REC_FIELD_DESCRIPTION_STR}
    };


    const std::map<std::string, DidRecField> DID_REC_FIELDS_NAME_MAP = {
      {DID_REC_FIELD_CLASS_STR,       DID_REC_FIELD_CLASS},
      {DID_REC_FIELD_TYPE_STR,        DID_REC_FIELD_TYPE},
      {DID_REC_FIELD_FORMAT_STR,      DID_REC_FIELD_FORMAT},
      {DID_REC_FIELD_DEFAULT_STR,     DID_REC_FIELD_DEFAULT},
      {DID_REC_FIELD_UNIT_STR,        DID_REC_FIELD_UNIT},
      {DID_REC_FIELD_RANGE_STR,       DID_REC_FIELD_RANGE},
      {DID_REC_FIELD_COMMENT_STR,     DID_REC_FIELD_COMMENT},
      {DID_REC_FIELD_TAGS_STR,        DID_REC_FIELD_TAGS},
      {DID_REC_FIELD_DESCRIPTION_STR, DID_REC_FIELD_DESCRIPTION}
    };


    class Record {
    public:

      static void DecodeFormat(const std::string& did_format,
                               FormatSpecifier& format_specifier);

      static std::string PrintRecords(std::vector<dit::did::Record>& records,
                                      const DidRecField fields = DID_REC_FIELD_ALL);


      Record();

      Record(const std::string& key_name,
             const ctd::file::Yaml& did);

      Record(const Record& source);

      ~Record();

      void Parse(const std::string& key_name,
                 const ctd::file::Yaml& did);

      const std::string& GetName() const;

      const std::string& GetAltName() const;

      const std::vector<std::string>& GetClasses() const;

      ctd::defines::DataType GetDataType() const;

      const std::string& GetFormat() const;

      template <class TYPE>
      TYPE GetDefaultValue() const;

      const std::string& GetUnit() const;

      const std::vector<Range>& GetRanges() const;

      const std::string& GetComment() const;

      const std::vector<std::string>& GetTags() const;

      const std::string& GetDescription() const;

      std::string ToString(DidRecField fields = DID_REC_FIELD_ALL,
                           const bool compact = false) const;

      Record& operator = (const Record& source);

    protected:
      std::string                     m_field_name;
      std::string                     m_alt_field_name; // Name without optional indeces.
      std::string                     m_org_name;
      std::vector<std::string> m_field_classes;
      ctd::defines::DataType          m_field_type;
      std::string                     m_field_format;
      std::string                     m_field_default;
      std::string                     m_field_unit;
      std::vector<Range>       m_field_ranges;
      std::string                     m_field_comment;
      std::vector<std::string> m_field_tags;
      std::string                     m_field_description;

    private:
      void _Copy(const Record& source);
    };

  }
}

#endif // !IFW_DIT_DID_RECORD_HPP_