attribute.hpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: yes (from oks/attribute.h to include/oks/attribute.hpp).

 
#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