attribute.hpp

Go to the documentation of this file.

 
#ifndef OKS_ATTRIBUTE_H
#define OKS_ATTRIBUTE_H
 
#include "oks/defs.hpp"
#include "oks/object.hpp"
 
#include <string>
#include <vector>
 
#include <boost/regex.hpp>
 
namespace dunedaq {
namespace oks {
 
 
class OksXmlOutputStream;
class OksXmlInputStream;
 
 
 
class OksRange
{
public:
 
  OksRange(const std::string& range, OksAttribute * a)
  {
    reset(range, a);
  }
 
  void
  reset(const std::string& range, OksAttribute * a);
 
  bool
  validate(const OksData&) const;
 
  inline bool
  is_empty()
  {
    return (m_less.empty() && m_equal.empty() && m_interval.empty() && m_great.empty() && m_like.empty());
  }
 
private:
 
  std::string m_range;
 
  std::list<OksData> m_less;
  std::list<OksData> m_equal;
  std::list<std::pair<OksData,OksData>> m_interval;
  std::list<OksData> m_great;
  std::list<boost::regex> m_like;
 
private:
 
  inline void
  clear()
  {
    m_range.clear();
 
    m_less.clear();
    m_equal.clear();
    m_interval.clear();
    m_great.clear();
    m_like.clear();
  }
};
 
 
 
class OksAttribute
{
  friend class OksKernel;
  friend class OksClass;
  friend class OksIndex;
  friend class OksObject;
  friend struct OksData;
 
public:
 
  enum Format {
    Oct = 8,
    Dec = 10,
    Hex = 16
  };
 
 
  OksAttribute(const std::string& name, OksClass * p = nullptr);
 
 
  OksAttribute(const std::string& name, const std::string& type, bool is_mv, const std::string& range, const std::string& init_v, const std::string& description, bool no_null, Format format = Dec, OksClass * p = nullptr);
 
 
  ~OksAttribute()
  {
    if (p_enumerators)
      delete p_enumerators;
 
    clean_range();
  }
 
 
  bool operator==(const class OksAttribute&) const;                      
  friend  std::ostream& operator<<(std::ostream&, const OksAttribute&);  
 
  const std::string&
  get_name() const noexcept
  {
    return p_name;
  }
 
 
  void
  set_name(const std::string& name);
 
 
  const std::string&
  get_type() const noexcept;
 
 
  void
  set_type(const std::string& type, bool skip_init = false);
 
 
  const std::string&
  get_range() const noexcept
  {
    return p_range;
  }
 
 
  void
  set_range(const std::string& range);
 
 
  static OksData::Type
  get_data_type(const std::string& type) noexcept;
 
 
  static OksData::Type
  get_data_type(const char * type, size_t len) noexcept;
 
 
  OksData::Type
  get_data_type() const noexcept
  {
    return p_data_type;
  }
 
 
  Format
  get_format() const noexcept
  {
    return p_format;
  }
 
 
  void
  set_format(Format format);
 
 
  bool
  is_integer() const noexcept;
 
 
  bool
  is_number() const noexcept;
 
 
  bool
  get_is_multi_values() const noexcept
  {
    return p_multi_values;
  }
 
 
  void
  set_is_multi_values(bool multi_values);
 
 
  const std::string&
  get_init_value() const noexcept
  {
    return p_init_value;
  }
 
 
  void
  set_init_value(const std::string& init_value);
 
 
  std::list<std::string>
  get_init_values() const;
 
 
  const std::string&
  get_description() const noexcept
  {
    return p_description;
  }
 
 
  void
  set_description(const std::string& description);
 
 
  bool
  get_is_no_null() const noexcept
  {
    return p_no_null;
  }
 
 
  void
  set_is_no_null(bool no_null);
 
  static bool
  find_token(const char * token, const char * range) noexcept;
 
  int
  get_enum_index(const char * s, size_t length) const noexcept;
 
  int
  get_enum_index(const std::string& s) const noexcept
  {
    return get_enum_index(s.data(), s.length());
  }
 
 
  const std::string *
  get_enum_value(const char * s, size_t length) const;
 
 
  const std::string *
  get_enum_value(const std::string& s) const
  {
    return get_enum_value(s.data(), s.length());
  }
 
 
  uint16_t
  get_enum_value(const OksData& d) const noexcept;
 
  const std::string *
  get_enum_string(uint16_t idx) const noexcept
  {
    return &(*p_enumerators)[idx];
  }
 
 
  static const char * bool_type;
  static const char * s8_int_type;
  static const char * u8_int_type;
  static const char * s16_int_type;
  static const char * u16_int_type;
  static const char * s32_int_type;
  static const char * u32_int_type;
  static const char * s64_int_type;
  static const char * u64_int_type;
  static const char * float_type;
  static const char * double_type;
  static const char * date_type;
  static const char * time_type;
  static const char * string_type;
  static const char * uid_type;
  static const char * enum_type;
  static const char * class_type;
 
  static Format
  str2format(const char *) noexcept;
  static const char *
  format2str(Format) noexcept;
 
private:
 
  std::string p_name;
  std::string p_range;
  OksData::Type p_data_type;
  bool p_multi_values;
  bool p_no_null;
  std::string p_init_value;
  Format p_format;
  std::string p_description;
  OksClass * p_class;
  std::vector<std::string> * p_enumerators;
  OksRange * p_range_obj;
  OksData p_init_data;
  OksData p_empty_init_data;
  bool p_ordered;
 
  inline void
  __set_data_type(const char * t, size_t len) noexcept;
 
  OksAttribute(OksData::Type t, const OksClass * c) noexcept :
      p_data_type(t), p_class(const_cast<OksClass*>(c)), p_enumerators(nullptr), p_range_obj(nullptr), p_ordered(false)
  {
    ;
  }
 
 
  OksAttribute(OksXmlInputStream&, OksClass *);
 
 
  void
  save(OksXmlOutputStream&) const;
 
  void
  init_enum();
 
  void
  init_range();
 
  inline void
  clean_range()
  {
    if (p_range_obj)
      {
        delete p_range_obj;
        p_range_obj = nullptr;
      }
  }
 
  void
  set_init_data()
  {
    p_init_data.set_init_value(this, false);
    p_empty_init_data.set_init_value(this, true);
  }
 
  static const char attribute_xml_tag[];
  static const char name_xml_attr[];
  static const char description_xml_attr[];
  static const char type_xml_attr[];
  static const char format_xml_attr[];
  static const char range_xml_attr[];
  static const char is_multi_value_xml_attr[];
  static const char mv_implement_xml_attr[];
  static const char init_value_xml_attr[];
  static const char is_not_null_xml_attr[];
  static const char ordered_xml_attr[];
 
};
 
inline void
OksAttribute::__set_data_type(const char * t, size_t len) noexcept
{
  p_data_type = get_data_type(t, len);
}
 
inline void
OksData::SetE(const char *s, size_t len, const OksAttribute *a)
{
  Clear();
  type = enum_type;
  data.ENUMERATION = a->get_enum_value(s, len);
}
 
inline void
OksData::SetE(const std::string &s, const OksAttribute *a)
{
  Clear();
  type = enum_type;
  data.ENUMERATION = a->get_enum_value(s);
}
 
inline void
OksData::SetE(const OksAttribute *a)
{
  Clear();
  type = enum_type;
  data.ENUMERATION = &((*(a->p_enumerators))[0]);
}
 
inline void
OksData::SetE(const OksString &s, const OksAttribute *a)
{
  Clear();
  type = enum_type;
  data.ENUMERATION = a->get_enum_value(s);
}
 
// profit from C++ string object vs. "char *" to create new string (string_type) or known string length (enum_type)
 
inline void
OksData::ReadFrom(const std::string& s, const OksAttribute * a)
{
  if (type == OksData::string_type)
    data.STRING = new OksString(s);
  else if (type == OksData::enum_type)
    data.ENUMERATION = a->get_enum_value(s);
  else
    SetValue(s.c_str(), a);
}
 
} // namespace oks
} // namespace dunedaq
 
#endif