class.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/class.h to include/oks/class.hpp).

 
#ifndef OKS_CLASS_H
#define OKS_CLASS_H
 
#include "oks/exceptions.hpp"
#include "oks/index.hpp"
 
#include <list>
#include <map>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <vector>
 
#include <boost/pool/pool_alloc.hpp>
 
namespace dunedaq {
namespace oks {
 
// Forward declarations
 
class OksAttribute;
class OksClass;
class OksFile;
class OksKernel;
class OksMethod;
class OksQuery;
class OksQueryExpression;
class OksRelationship;
class OksXmlInputStream;
class OksXmlOutputStream;


 
class CannotFindSuperClass : public exception
{
 
public:
  CannotFindSuperClass(const OksClass& c, const std::string& name) noexcept
    : exception(fill(c, name), 0)
  {
  }
  virtual ~CannotFindSuperClass() noexcept {}
 
private:
  static std::string fill(const OksClass& c, const std::string& name) noexcept;
};

 
class AttributeConversionFailed : public exception
{
 
public:
  AttributeConversionFailed(const OksAttribute& a, const OksObject* o, const exception& reason) noexcept
    : exception(fill(a, o, reason.what()), reason.level() + 1)
  {
  }
  virtual ~AttributeConversionFailed() noexcept {}
 
private:
  static std::string fill(const OksAttribute& a, const OksObject* o, const std::string& reason) noexcept;
};

 
class CannotRegisterClass : public exception
{
 
public:
  CannotRegisterClass(const OksClass& c, const std::string& what, const exception& reason) noexcept
    : exception(fill(c, what, reason.what()), reason.level() + 1)
  {
  }
  CannotRegisterClass(const OksClass& c, const std::string& what, const std::string& reason) noexcept
    : exception(fill(c, what, reason), 0)
  {
  }
  virtual ~CannotRegisterClass() noexcept {}
 
private:
  static std::string fill(const OksClass& c, const std::string& what, const std::string& reason) noexcept;
};

 
class CannotDestroyClass : public exception
{
 
public:
  CannotDestroyClass(const OksClass& c, const exception& reason) noexcept
    : exception(fill(c, reason.what()), reason.level() + 1)
  {
  }
  CannotDestroyClass(const OksClass& c, const std::string& reason) noexcept
    : exception(fill(c, reason), 0)
  {
  }
  virtual ~CannotDestroyClass() noexcept {}
 
private:
  static std::string fill(const OksClass& c, const std::string& reason) noexcept;
};

 
class ObjectOperationFailed : public exception
{
 
public:
  ObjectOperationFailed(const OksClass& c, const std::string& oid, const char* op, const exception& reason) noexcept
    : exception(fill(c, oid, op, reason.what()), reason.level() + 1)
  {
  }
  ObjectOperationFailed(const OksClass& c, const std::string& oid, const char* op, const std::string& reason) noexcept
    : exception(fill(c, oid, op, reason), 0)
  {
  }
  virtual ~ObjectOperationFailed() noexcept {}
 
private:
  static std::string fill(const OksClass& c,
                          const std::string& oid,
                          const char* op,
                          const std::string& reason) noexcept;
};

 
class SetOperationFailed : public exception
{
 
public:
  SetOperationFailed(const char* op, const exception& reason) noexcept
    : exception(fill(op, reason.what()), reason.level() + 1)
  {
  }
  SetOperationFailed(const char* op, const std::string& reason) noexcept
    : exception(fill(op, reason), 0)
  {
  }
  virtual ~SetOperationFailed() noexcept {}
 
private:
  static std::string fill(const char* op, const std::string& reason) noexcept;
};

 
class QueryFailed : public exception
{
 
public:
  QueryFailed(const OksQueryExpression& query, const OksClass& c, const exception& reason) noexcept
    : exception(fill(query, c, reason.what()), reason.level() + 1)
  {
  }
  QueryFailed(const OksQueryExpression& query, const OksClass& c, const std::string& reason) noexcept
    : exception(fill(query, c, reason), 0)
  {
  }
  virtual ~QueryFailed() noexcept {}
 
private:
  static std::string fill(const OksQueryExpression& query, const OksClass& c, const std::string& reason) noexcept;
};

 
class BadReqExp : public exception
{
 
public:
  BadReqExp(const std::string& what, const std::string& reason) noexcept
    : exception(fill(what, reason), 0)
  {
  }
  virtual ~BadReqExp() noexcept {}
 
private:
  static std::string fill(const std::string& what, const std::string& reason) noexcept;
};

 
class OksClass
{
  friend class OksObject;
  friend class OksKernel;
  friend class OksAttribute;
  friend class OksRelationship;
  friend class OksMethod;
  friend class OksMethodImplementation;
  friend class OksIndex;
  friend class OksSortedClass;
 
public:
#ifndef ERS_NO_DEBUG
 
  // Declare set of pointers to OksClass sorted by name
 
  struct SortByName
  {
    bool operator()(OksClass* c1, OksClass* c2) const { return c1->get_name() < c2->get_name(); }
  };
 
  typedef std::set<OksClass*, SortByName> Set;
 
#endif
 
  struct SortStr
  {
    bool operator()(const char* c1, const char* c2) const { return (strcmp(c1, c2) < 0); }
  };
 
  typedef std::map<const char*, OksClass*, SortStr> Map;
 
  typedef std::list<OksClass*, boost::fast_pool_allocator<OksClass*>> FList;

 
  OksClass(const std::string& name, OksKernel* kernel, bool transient = false);

 
  OksClass(const std::string& name,
           const std::string& description,
           bool is_abstract,
           OksKernel* kernel,
           bool transient = false);

 
  OksClass(OksKernel* kernel, const std::string& name, const std::string& description, bool is_abstract);

 
  static void destroy(OksClass* c);

 
  bool operator==(const OksClass&) const;

 
  bool operator!=(const OksClass&) const;

 
  friend std::ostream& operator<<(std::ostream&, const OksClass&);
 
  friend std::ostream& operator<<(std::ostream&, const OksObject&);

 
  bool compare_without_methods(const OksClass& c) const noexcept;
 
  // methods to access class external information
 
public:
 
  OksKernel* get_kernel() const noexcept { return p_kernel; }

 
  OksFile* get_file() const noexcept { return p_file; }

 
  void set_file(OksFile* f, bool update_owner = true);
 
  // methods to access class properties
 
public:
 
  const std::string& get_name() const noexcept { return p_name; }

 
  const std::string& get_description() const noexcept { return p_description; }

 
  void set_description(const std::string& description);

 
  bool get_is_abstract() const noexcept { return p_abstract; }

 
  void set_is_abstract(bool abstract);
 
  // methods to access class hierarchy description
 
public:
 
  const FList* all_super_classes() const noexcept { return p_all_super_classes; }

 
  const std::list<std::string*>* direct_super_classes() const noexcept { return p_super_classes; }

 
  OksClass* find_super_class(const std::string&) const noexcept;

 
  bool has_direct_super_class(const std::string&) const noexcept;

 
  void add_super_class(const std::string& name);

 
  void k_add_super_class(const std::string& name);

 
  void remove_super_class(const std::string& name);

 
  void swap_super_classes(const std::string& c1, const std::string& c2);

 
  const FList* all_sub_classes() const noexcept { return p_all_sub_classes; }
 
  // methods to access class attributes description
 
public:
 
  const std::list<OksAttribute*>* all_attributes() const noexcept { return p_all_attributes; }

 
  const std::list<OksAttribute*>* direct_attributes() const noexcept { return p_attributes; }

 
  OksAttribute* find_attribute(const std::string& name) const noexcept;

 
  OksAttribute* find_direct_attribute(const std::string& name) const noexcept;

 
  void add(OksAttribute* a);

 
  void k_add(OksAttribute* a);

 
  void remove(const OksAttribute* a);

 
  void swap(const OksAttribute* a1, const OksAttribute* a2);

 
  size_t number_of_direct_attributes() const noexcept;

 
  size_t number_of_all_attributes() const noexcept;

 
  OksClass* source_class(const OksAttribute* a) const noexcept;
 
  // methods to access class relationships description

 
  const std::list<OksRelationship*>* all_relationships() const noexcept { return p_all_relationships; }

 
  const std::list<OksRelationship*>* direct_relationships() const noexcept { return p_relationships; }

 
  OksRelationship* find_relationship(const std::string& name) const noexcept;

 
  OksRelationship* find_direct_relationship(const std::string& name) const noexcept;

 
  void add(OksRelationship* r);

 
  void k_add(OksRelationship* r);

 
  void remove(const OksRelationship* r, bool call_delete = true);

 
  void swap(const OksRelationship* r1, const OksRelationship* r2);

 
  size_t number_of_direct_relationships() const noexcept;

 
  size_t number_of_all_relationships() const noexcept;

 
  OksClass* source_class(const OksRelationship* r) const noexcept;
 
  // methods to access class methods description

 
  const std::list<OksMethod*>* all_methods() const noexcept { return p_all_methods; }

 
  const std::list<OksMethod*>* direct_methods() const noexcept { return p_methods; }

 
  OksMethod* find_method(const std::string& name) const noexcept;

 
  OksMethod* find_direct_method(const std::string& name) const noexcept;

 
  void add(OksMethod* m);

 
  void remove(const OksMethod* m);

 
  void swap(const OksMethod* m1, const OksMethod* m2);

 
  size_t number_of_direct_methods() const noexcept;

 
  size_t number_of_all_methods() const noexcept;

 
  OksClass* source_class(const OksMethod* m) const noexcept;
 
  // methods to access class instances

 
  size_t number_of_objects() const noexcept;

 
  const OksObject::Map* objects() const noexcept { return p_objects; }

 
  std::list<OksObject*>* create_list_of_all_objects() const noexcept;

 
  OksObject* get_object(const std::string& id) const noexcept;

 
  OksObject* get_object(const std::string* id) const noexcept { return get_object(*id); }

 
  OksObject::List* execute_query(OksQuery* query) const;

 
  OksDataInfo* data_info(const std::string& s) const noexcept { return p_data_info->find(s)->second; }

 
  OksDataInfo* get_data_info(const std::string& s) const noexcept
  {
    auto it = p_data_info->find(s);
    return (it != p_data_info->end() ? it->second : nullptr);
  }

 
  enum ChangeType
  {
 
    ChangeSuperClassesList,
    ChangeSubClassesList,
    ChangeDescription,
    ChangeIsAbstaract,
 
    ChangeAttributesList,
    ChangeAttributeType,
    ChangeAttributeRange,
    ChangeAttributeFormat,
    ChangeAttributeMultiValueCardinality,
    ChangeAttributeInitValue,
    ChangeAttributeDescription,
    ChangeAttributeIsNoNull,
 
    ChangeRelationshipsList,
    ChangeRelationshipClassType,
    ChangeRelationshipDescription,
    ChangeRelationshipLowCC,
    ChangeRelationshipHighCC,
    ChangeRelationshipComposite,
    ChangeRelationshipExclusive,
    ChangeRelationshipDependent,
 
    ChangeMethodsList,
    ChangeMethodDescription,
    ChangeMethodImplementation
 
  };

 
  typedef void (*NotifyFN)(OksClass*);

 
  typedef void (*ChangeNotifyFN)(OksClass*, ChangeType, const void*);
 
private:
  std::string p_name;
  std::string p_description;
  std::list<std::string*>* p_super_classes;
  std::list<OksAttribute*>* p_attributes;
  std::list<OksRelationship*>* p_relationships;
  std::list<OksMethod*>* p_methods;
  bool p_abstract;
  bool p_transient;
  bool p_to_be_deleted;
 
  FList* p_all_super_classes;
  FList* p_all_sub_classes;
  std::list<OksAttribute*>* p_all_attributes;
  std::list<OksRelationship*>* p_all_relationships;
  std::list<OksMethod*>* p_all_methods;
 
  std::vector<OksClass*>* p_inheritance_hierarchy;
  unsigned int p_id;
 
  OksFile* p_file;
  OksKernel* p_kernel;
 
  size_t p_instance_size;
 
  OksDataInfo::Map* p_data_info;
  OksObject::Map* p_objects;
  OksIndex::Map* p_indices;
 
  mutable std::shared_mutex p_mutex;
  mutable std::mutex p_unique_id_mutex;
 
  static NotifyFN create_notify_fn;
  static ChangeNotifyFN change_notify_fn;
  static NotifyFN delete_notify_fn;
 
  // to be used by OksKernel only
 
  ~OksClass();
  OksClass(OksXmlInputStream&, OksKernel*);
 
  template<class T>
  static void destroy_map(T map);
  template<class T>
  static void destroy_list(T list);
 
  // transient class for OksKernel::find_class()
 
  inline OksClass(const char* name, size_t len);
 
  void save(OksXmlOutputStream&) const;
 
  void add(OksObject*);
  void remove(OksObject*);
  void registrate_class(bool skip_registered);
  void registrate_class_change(ChangeType, const void*, bool = true);
  void registrate_attribute_change(OksAttribute*);
  void registrate_relationship_change(OksRelationship*);
  void registrate_instances();
 
  void add_super_classes(FList*) const;
  void create_super_classes();
  void create_sub_classes();
  void create_attributes();
  void create_relationships();
  void create_methods();
 
  void lock_file(const char*);
 
  bool check_relationships(std::ostringstream& out, bool print_file_name) const noexcept;
 
  // valid xml tags and attributes
 
  static const char class_xml_tag[];
  static const char name_xml_attr[];
  static const char description_xml_attr[];
  static const char is_abstract_xml_attr[];
  static const char superclass_xml_attr[];
};
 
//
// INLINE METHODS
//
 
inline bool
OksClass::operator==(const OksClass& c) const
{
  return ((this == &c || p_name == c.p_name) ? true : false);
}
 
inline size_t
OksClass::number_of_direct_attributes() const noexcept
{
  return (p_attributes ? p_attributes->size() : 0);
}
 
inline size_t
OksClass::number_of_all_attributes() const noexcept
{
  return (p_all_attributes ? p_all_attributes->size() : 0);
}
 
inline size_t
OksClass::number_of_direct_relationships() const noexcept
{
  return (p_relationships ? p_relationships->size() : 0);
}
 
inline size_t
OksClass::number_of_all_relationships() const noexcept
{
  return (p_all_relationships ? p_all_relationships->size() : 0);
}
 
inline size_t
OksClass::number_of_direct_methods() const noexcept
{
  return (p_methods ? p_methods->size() : 0);
}
 
inline size_t
OksClass::number_of_all_methods() const noexcept
{
  return (p_all_methods ? p_all_methods->size() : 0);
}
 
inline OksClass::OksClass(const char* name, size_t len)
  : p_name(name, len)
  , p_super_classes(0)
  , p_attributes(0)
  , p_relationships(0)
  , p_methods(0)
  , p_abstract(false)
  , p_transient(true)
  , p_to_be_deleted(false)
  , p_all_super_classes(0)
  , p_all_sub_classes(0)
  , p_all_attributes(0)
  , p_all_relationships(0)
  , p_all_methods(0)
  , p_inheritance_hierarchy(0)
  , p_kernel(0)
  , p_instance_size(0)
  , p_data_info(0)
  , p_objects(0)
  , p_indices(0)
{
  ;
}
 
} // namespace oks
} // namespace dunedaq
#endif