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/index.hpp"
#include "oks/exceptions.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