object.hpp

Go to the documentation of this file.

 
#ifndef OKS_OBJECT_H
#define OKS_OBJECT_H
 
#include "oks/defs.hpp"
#include "oks/file.hpp"
#include "oks/exceptions.hpp"
 
#include <stdint.h>
 
#include <string>
#include <list>
#include <set>
#include <map>
#include <functional>
 
#include <boost/date_time/gregorian/greg_date.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/pool/pool_alloc.hpp>
 
#include <unordered_map>
#include <unordered_set>
 
 
namespace dunedaq {
namespace oks {
 
 
 
class   OksKernel;
class   OksFile;
struct  OksData;
class   OksClass;
class   OksObject;
class   OksAttribute;
class   OksRelationship;
class   OksMethod;
class   OksQueryExpression;
struct  OksAliasTable;
class   OksXmlOutputStream;
class   OksXmlInputStream;
struct  OksXmlToken;
struct  OksXmlValue;
struct  OksXmlRelValue;
 
 
  class QueryPathExpression;
  class QueryPath;
 
 
  class FailedCreateObject : public exception {
 
    public:
 
      FailedCreateObject(const OksObject * o, const exception& reason) noexcept : exception (fill(o, reason.what()), reason.level() + 1) { }
 
      FailedCreateObject(const OksObject * o, const std::string& reason) noexcept : exception (fill(o, reason), 0) { }
 
      virtual ~FailedCreateObject() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * o, const std::string& reason);
  };
 
 
  class FailedReadObject : public exception {
 
    public:
 
      FailedReadObject(const OksObject * o, const std::string& what, const exception& reason) noexcept : exception (fill(o, what, reason.what()), reason.level() + 1) { }
 
      FailedReadObject(const OksObject * o, const std::string& what, const std::string& reason) noexcept : exception (fill(o, what, reason), 0) { }
 
      virtual ~FailedReadObject() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * o, const std::string& what, const std::string& reason);
  };
 
 
  class FailedSaveObject : public exception {
 
    public:
 
      FailedSaveObject(const OksObject * o, const exception& reason) noexcept : exception (fill(o, reason.what()), reason.level() + 1) { }
 
      FailedSaveObject(const OksObject * o, const std::string& reason) noexcept : exception (fill(o, reason), 0) { }
 
      virtual ~FailedSaveObject() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * o, const std::string& reason);
 
  };
 
 
  class FailedRenameObject : public exception {
 
    public:
 
      FailedRenameObject(const OksObject * o, const exception& reason) noexcept : exception (fill(o, reason.what()), reason.level() + 1) { }
 
      FailedRenameObject(const OksObject * o, const std::string& reason) noexcept : exception (fill(o, reason), 0) { }
 
      virtual ~FailedRenameObject() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * o, const std::string& reason);
 
  };
 
 
  class FailedDestoyObject : public exception {
 
    public:
 
      FailedDestoyObject(const OksObject * o, const exception& reason) noexcept : exception (fill(o, reason.what()), reason.level() + 1) { }
 
      FailedDestoyObject(const OksObject * o, const std::string& reason) noexcept : exception (fill(o, reason), 0) { }
 
      virtual ~FailedDestoyObject() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * o, const std::string& reason);
 
  };
 
 
  class AttributeRangeError : public exception {
 
    public:
 
      AttributeRangeError(const OksData * d, const std::string& range) noexcept : exception (fill(d, range), 0) { }
 
      virtual ~AttributeRangeError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksData * d, const std::string& range);
 
  };
 
 
  class AttributeReadError : public exception {
 
    public:
 
      AttributeReadError(const char * value, const char * type, const exception& reason) noexcept : exception (fill(value, type, reason.what()), reason.level() + 1) { }
 
      AttributeReadError(const char * value, const char * type, const std::string& reason) noexcept : exception (fill(value, type, reason), 0) { }
 
      AttributeReadError(const char * type, const exception& reason) noexcept : exception (fill(type, reason.what()), reason.level() + 1) { }
 
      AttributeReadError(const char * type, const std::string& reason) noexcept : exception (fill(type, reason), 0) { }
 
      virtual ~AttributeReadError() noexcept { }
 
 
    private:
 
      static std::string fill(const char * value, const char * type, const std::string& reason);
      static std::string fill(const char * type, const std::string& reason);
 
  };
 
 
  class ObjectSetError : public exception {
 
    public:
 
      ObjectSetError(const OksObject * obj, bool is_rel, const std::string& name, const exception& reason) noexcept : exception (fill(obj, is_rel, name, reason.what()), reason.level() + 1) { }
 
      ObjectSetError(const OksObject * obj, bool is_rel, const std::string& name, const std::string& reason) noexcept : exception (fill(obj, is_rel, name, reason), 0) { }
 
      virtual ~ObjectSetError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * obj, bool is_rel, const std::string& name, const std::string& reason);
 
  };
 
 
  class ObjectGetError : public exception {
 
    public:
 
      ObjectGetError(const OksObject * obj, bool is_rel, const std::string& name, const exception& reason) noexcept : exception (fill(obj, is_rel, name, reason.what()), reason.level() + 1) { }
 
      ObjectGetError(const OksObject * obj, bool is_rel, const std::string& name, const std::string& reason) noexcept : exception (fill(obj, is_rel, name, reason), 0) { }
 
      virtual ~ObjectGetError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * obj, bool is_rel, const std::string& name, const std::string& reason);
 
  };
 
 
  class ObjectInitError : public exception {
 
    public:
 
      ObjectInitError(const OksObject * obj, const std::string& why, const exception& reason) noexcept : exception (fill(obj, why, reason.what()), reason.level() + 1) { }
 
      ObjectInitError(const OksObject * obj, const std::string& why, const std::string& reason) noexcept : exception (fill(obj, why, reason), 0) { }
 
      virtual ~ObjectInitError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * obj, const std::string& why, const std::string& reason);
 
  };
 
 
 
  class ObjectBindError : public exception {
 
    public:
 
      ObjectBindError(const OksObject * obj, const OksData * data, const OksRelationship * rel, bool is_error, const std::string& why, const exception& reason) noexcept :
        exception (fill(obj, rel, why, reason.what()), reason.level() + 1),
    p_data(data), p_is_error(is_error) { }
 
      ObjectBindError(const OksObject * obj, const OksData * data, const OksRelationship * rel, bool is_error, const std::string& why, const std::string& reason) noexcept :
        exception (fill(obj, rel, why, reason), 0),
    p_data(data), p_is_error(is_error) { }
 
      virtual ~ObjectBindError() noexcept { }
 
      const OksData * p_data;
      const OksRelationship * p_rel;
      bool p_is_error;
 
    private:
 
      std::string fill(const OksObject * obj, const OksRelationship * rel, const std::string& why, const std::string& reason);
 
  };
 
 
 
  class AddRcrError : public exception {
 
    public:
 
      AddRcrError(const OksObject * obj, const std::string& name, const OksObject * p1, const OksObject * p2) noexcept : exception (fill(obj, name, p1, p2), 0) { }
 
      virtual ~AddRcrError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksObject * obj, const std::string& name, const OksObject * p1, const OksObject * p2);
 
  };
 
 
 
 
struct OksDataInfo {
 
 
  typedef std::map<std::string, OksDataInfo *> Map;
 
 
 
  OksDataInfo(size_t o, const OksAttribute * a) : offset (o), attribute (a), relationship(nullptr)  { ; }
  OksDataInfo(size_t o, const OksRelationship * r) : offset (o), attribute (nullptr), relationship(r)  { ; }
 
  size_t                   offset;          // offset of OKS data in the object
  const OksAttribute *     attribute;
  const OksRelationship *  relationship;
};
 
 
 
class OksString : public std::string {
  friend class OksKernel; 
 
  public:
 
    OksString   () {;}
    OksString   (const std::string& s) : std::string(s) {;}
    OksString   (const char * s) : std::string(s) {;}
    OksString   (const char * s, size_t n) : std::string(s,n) {;}
    OksString   (const std::string&s, std::string::size_type n) : std::string(s,0,n) {;}
 
    void *      operator new(size_t) {return boost::fast_pool_allocator<OksString>::allocate();}
    void        operator delete(void *ptr) {boost::fast_pool_allocator<OksString>::deallocate(reinterpret_cast<OksString*>(ptr));}
};
 
 
 
inline bool
operator==(const OksString& s1, const OksString& s2)
{
  return ( *(static_cast<const std::string *>(&s1)) == *(static_cast<const std::string *>(&s2)) );
}
 
 
 
inline bool
operator==(const OksString& s1, const std::string& s2)
{
  return ( *(static_cast<const std::string *>(&s1)) == s2 );
}
 
 
 
inline bool
operator==(const OksString& s1, const char *s2)
{
  return (*(static_cast<const std::string *>(&s1)) == s2);
}
 
 
 
inline bool
operator<(const OksString& s1, const OksString& s2)
{
  return ( *(static_cast<const std::string *>(&s1)) < *(static_cast<const std::string *>(&s2)) );
}
 
 
 
inline std::ostream&
operator<<(std::ostream& s, const OksString& str)
{
  s << *(static_cast<const std::string *>(&str));
  
  return s;
}
 
 
  // forward declaration for private OKS structures declared in non-installing src/oks_utils.hpp
 
  struct ReloadObjects;    
  struct ReadFileParams;   
 
 
 
struct OksData {
  friend class OksObject;
  friend class OksKernel;
 
  public:
 
    typedef std::list<OksData *, boost::fast_pool_allocator<OksData *> > List;
 
    enum Type {
      unknown_type  = 0,
      s8_int_type   = 1,
      u8_int_type   = 2,
      s16_int_type  = 3,
      u16_int_type  = 4,
      s32_int_type  = 5,
      u32_int_type  = 6,
      s64_int_type  = 7,
      u64_int_type  = 8,
      float_type    = 9,
      double_type   = 10,
      bool_type     = 11,
      class_type        = 12,
      object_type   = 13,
      date_type     = 14,
      time_type     = 15,
      string_type   = 16,
      list_type     = 17,
      uid_type      = 18,
      uid2_type     = 19,
      enum_type     = 20
    } type;
 
    union Data {
      int8_t               S8_INT;
      uint8_t                  U8_INT;
      int16_t              S16_INT;
      uint16_t                 U16_INT;
      int32_t              S32_INT;
      uint32_t                 U32_INT;
      int64_t                  S64_INT;
      uint64_t                 U64_INT;
      float                    FLOAT;
      double                   DOUBLE;
      bool                     BOOL;
      const OksClass *         CLASS;
      OksObject *              OBJECT;
      uint32_t                 DATE; // boost::gregorian::date    => ugly, but member with constructor not allowed in union
      uint64_t                 TIME; // boost::posix_time::ptime  => ......................................................
      OksString *          STRING;
      List *                   LIST;
      struct {
        const OksClass *         class_id;
        OksString *              object_id;
      }                        UID;
      struct {
        OksString *              class_id;
        OksString *              object_id;
      }                        UID2;
      const std::string *      ENUMERATION;
    } data;
 
    OksData()                                           {Clear2();}
    OksData(int8_t c)                                   {Clear2(); Set(c);}
    OksData(uint8_t c)                                  {Clear2(); Set(c);}
    OksData(int16_t i)                                  {Clear2(); Set(i);}
    OksData(uint16_t i)                                 {Clear2(); Set(i);}
    OksData(int32_t i)                                  {Clear2(); Set(i);}
    OksData(uint32_t i)                                 {Clear2(); Set(i);}
    OksData(int64_t i)                                  {Clear2(); Set(i);}
    OksData(uint64_t i)                                 {Clear2(); Set(i);}
    OksData(const float& f)                             {Clear2(); Set(f);}
    OksData(const double& d)                            {Clear2(); Set(d);}
    OksData(bool b)                                     {Clear2(); Set(b);}
    OksData(boost::gregorian::date d)                   {Clear2(); Set(d);}
    OksData(boost::posix_time::ptime t)                 {Clear2(); Set(t);}
    OksData(OksString *s)                               {Clear2(); Set(s);}
    OksData(const char *s)                              {Clear2(); Set(s);}
    OksData(const std::string &s)                       {Clear2(); Set(s);}
    OksData(const OksString &s)                         {Clear2(); Set(s);}
    OksData(const char *s, size_t len, const OksAttribute *a) {Clear2(); SetE(s,len,a);}
    OksData(const std::string &s, const OksAttribute *a){Clear2(); SetE(s,a);}
    OksData(const OksString &s, const OksAttribute *a)  {Clear2(); SetE(s,a);}
    OksData(const OksClass * c)                         {Clear2(); Set(c);}
    OksData(List *l)                                    {Clear2(); Set(l);}
    OksData(OksObject *o)                               {Clear2(); Set(o);}
    OksData(const OksClass *c, const char * o)          {Clear(); Set(c, o);}
    OksData(const OksClass *c, const OksString& o)      {Clear(); Set(c, o);}
    OksData(const std::string &c, const std::string &o) {Clear2(); Set(c, o);}
 
    ~OksData()                                          {Clear();}
 
    void Clear();
    void Clear2()                                       {type = unknown_type;}
 
    void Set(int8_t c)                          {Clear(); type = s8_int_type; data.S8_INT = c;}
    void Set(uint8_t c)                         {Clear(); type = u8_int_type; data.U8_INT = c;}
    void Set(int16_t i)                         {Clear(); type = s16_int_type; data.S16_INT = i;}
    void Set(uint16_t i)                        {Clear(); type = u16_int_type; data.U16_INT = i;}
    void Set(int32_t i)                         {Clear(); type = s32_int_type; data.S32_INT = i;}
    void Set(uint32_t i)                        {Clear(); type = u32_int_type; data.U32_INT = i;}
    void Set(int64_t i)                         {Clear(); type = s64_int_type; data.S64_INT = i;}
    void Set(uint64_t i)                        {Clear(); type = u64_int_type; data.U64_INT = i;}
    void Set(const float& f)                        {Clear(); type = float_type; data.FLOAT = f;}
    void Set(const double& d)                       {Clear(); type = double_type; data.DOUBLE = d;}
    void Set(bool b)                            {Clear(); type = bool_type; data.BOOL = b;}
    void SetFast(boost::gregorian::date d);
    void SetFast(boost::posix_time::ptime t);
    void Set(boost::gregorian::date d)                  {Clear(); type = date_type; SetFast(d);}
    void Set(boost::posix_time::ptime t)                {Clear(); type = time_type; SetFast(t);}
    void Set(OksString *s)                      {Clear(); type = string_type; data.STRING = s;}
    void Set(const char *s)                     {Clear(); type = string_type; data.STRING = new OksString(s);}
    void Set(const std::string &s)                  {Clear(); type = string_type; data.STRING = new OksString(s);}
    void Set(const OksString &s)                    {Clear(); type = string_type; data.STRING = new OksString(s);}
    void Set(const OksClass * c)                        {Clear(); type = class_type; data.CLASS = c;}
    inline void SetE(OksString *s, const OksAttribute *a);
    inline void SetE(const char *s, size_t len, const OksAttribute *a);
    inline void SetE(const std::string &s, const OksAttribute *a);
    inline void SetE(const OksAttribute *a);
    inline void SetE(const OksString &s, const OksAttribute *a);
    void Set(List * l)                          {Clear(); type = list_type; data.LIST = l;}
    void Set(OksObject *o)                      {Clear(); type = object_type; data.OBJECT = o;}
    void Set(const OksClass *c, const OksString& s)     {Clear(); type = uid_type; data.UID.class_id = c; data.UID.object_id = new OksString(s);}
    void Set(const OksClass *c, OksString* s)           {Clear(); type = uid_type; data.UID.class_id = c; data.UID.object_id = s;}
    void Set(const OksString &c, const OksString &s)    {Clear(); type = uid2_type; data.UID2.class_id = new OksString(c); data.UID2.object_id = new OksString(s);}
    void Set(OksString *c, OksString *s)                {Clear(); type = uid2_type; data.UID2.class_id = c; data.UID2.object_id = s;}
 
    inline void ReadFrom(const char *, Type, const OksAttribute *);
 
    inline void ReadFrom(const std::string&, const OksAttribute *);
 
    void SetNullValue(const OksAttribute * a);
 
    void SetValue(const char * s, const OksAttribute * a);
 
    void SetValues(const char *, const OksAttribute * a);
 
    void ReadFrom(const OksRelationship *) noexcept;
 
    void WriteTo(OksXmlOutputStream&, bool) const;
 
    void WriteTo(OksXmlOutputStream&) const;
 
    void ConvertTo(OksData *, const OksRelationship *) const;
 
    boost::gregorian::date date() const noexcept;
    boost::posix_time::ptime time() const noexcept;
 
 
    void cvt(OksData * to, const OksAttribute * attr) const;
 
    std::string str(int base = 0) const;
    std::string str(const OksKernel *) const;
 
 
    void check_range(const OksAttribute * a) const;
 
 
    void set_init_value(const OksAttribute * attr, bool skip_init);
 
    OksData& operator=(const OksData& d)
    {
      if(&d != this) {
        Clear();
        copy(d);
      }
 
      return *this;
    }
 
    OksData(const OksData& d)
    {
      if(&d != this) {
        copy(d);
      }
    }
 
    bool operator==(const OksData &) const;
    bool operator!=(const OksData &) const;
    bool operator<=(const OksData &) const; //report incompatible data types
    bool operator>=(const OksData &) const; //report incompatible data types
    bool operator<(const OksData &) const;  //report incompatible data types
    bool operator>(const OksData &) const;  //report incompatible data types
    friend std::ostream& operator<<(std::ostream&, const OksData&);
    void* operator new(size_t) {return boost::fast_pool_allocator<OksData>::allocate();}
    void operator delete(void *ptr) {boost::fast_pool_allocator<OksData>::deallocate(reinterpret_cast<OksData*>(ptr));}
 
    void sort(bool ascending = true);
 
    static bool is_object(Type t)
    {
      return (t == object_type || t == uid_type || t == uid2_type);
    }
 
  private:
 
    void copy(const OksData &);
 
    bool is_le(const OksData &) const noexcept; // fast version of operator<=(const OksData &)
    bool is_ge(const OksData &) const noexcept; // fast version of operator>=(const OksData &)
    bool is_l(const OksData &) const noexcept;  // fast version of operator<(const OksData &)
    bool is_g(const OksData &) const noexcept;  // fast version of operator>(const OksData &)
 
 
    void read(const oks::ReadFileParams&, const OksAttribute *, int32_t);     // read mv attribute
    void read(const oks::ReadFileParams&, const OksAttribute *);              // read sv attribute
    void read(const OksAttribute *, const OksXmlValue&);                      // read sv attribute for "data" format
    void read(const OksAttribute *, const oks::ReadFileParams&);              // read mv attribute for "data" format
 
    void read(const oks::ReadFileParams&, const OksRelationship*, int32_t);   // read mv relationship
    void read(const oks::ReadFileParams&, const OksRelationship*);            // read sv relationship
    void read(const OksRelationship *, const OksXmlRelValue&);                // read sv relationship for "data" format
    void read(const OksRelationship *, const oks::ReadFileParams&);           // read mv relationship for "data" format
 
    OksData(const oks::ReadFileParams& params, const OksAttribute * a, int32_t n) {Clear2(); read(params, a, n);}
    OksData(const oks::ReadFileParams& params, const OksAttribute * a) {Clear2(); read(params, a);}
    OksData(const OksAttribute * a, const OksXmlValue& value) {Clear2(); read(a, value);}
    OksData(const OksAttribute * a, const oks::ReadFileParams& params) {Clear2(); read(a, params);}
 
    OksData(const oks::ReadFileParams& params, const OksRelationship *r, int32_t n) {Clear2(); read(params, r, n);}
    OksData(const oks::ReadFileParams& params, const OksRelationship *r) {Clear2(); read(params, r);}
    OksData(const OksRelationship * r, const OksXmlRelValue& value) {Clear2(); read(r, value);}
    OksData(const OksRelationship * r, const oks::ReadFileParams& params) {Clear2(); read(r, params);}
 
    void WriteTo(OksXmlOutputStream&, OksKernel *, OksAliasTable *, bool, bool) const;
 
    bool IsConsistent(const OksRelationship *r, const OksObject *o, const char *msg);
 
    const std::string& __oid() const;
    const std::string& __cn() const;
};
 
 
inline void
OksData::ReadFrom(const char * s, Type t, const OksAttribute * a)
{
  Clear();
  type = t;
  SetValue(s, a);
}
 
 
struct OksRCR {
  friend class OksKernel;
  
  public:
  
    OksRCR          (OksObject *o, const OksRelationship *r) :
                              obj (o), relationship (r) {;}
 
    void *                  operator new(size_t) {return boost::fast_pool_allocator<OksRCR>::allocate();}
    void                    operator delete(void *ptr) {boost::fast_pool_allocator<OksRCR>::deallocate(reinterpret_cast<OksRCR*>(ptr));}
 
    OksObject *         obj;
    const OksRelationship * relationship;
 
};
 
  struct hash_str
  {
    inline size_t operator() ( const std::string * x ) const {
      return std::hash<std::string>()(*x);
    }
  };
 
  struct equal_str
  {
    inline bool operator()(const std::string * __x, const std::string * __y) const {
      return ((__x == __y) || (*__x == *__y));
    }
  };
 
  struct hash_obj_ptr
  {
    inline size_t operator() ( const OksObject * x ) const {
      return reinterpret_cast<size_t>(x);
    }
  };
 
  struct equal_obj_ptr
  {
    inline bool operator()(const OksObject * __x, const OksObject * __y) const {
      return (__x == __y);
    }
  };
 
  struct hash_class_ptr
  {
    inline size_t operator() ( const OksClass * x ) const {
      return reinterpret_cast<size_t>(x);
    }
  };
 
  struct equal_class_ptr
  {
    inline bool operator()(const OksClass * __x, const OksClass * __y) const {
      return (__x == __y);
    }
  };
  
  typedef std::unordered_set<const OksClass *, oks::hash_class_ptr, oks::equal_class_ptr> ClassSet;
 
 
class OksObject
{
  friend class  OksClass;
  friend struct OksData;
  friend class  OksKernel;
  friend class  OksIndex;
  friend class  OksObjectSortBy;
  friend struct OksLoadObjectsJob;
  friend struct oks::ReadFileParams;
  friend struct oks::ReloadObjects;
 
  public:
 
    typedef void (*notify_obj)(OksObject *, void *);
 
    struct SortById {
      bool operator() (const std::string * s1, const std::string * s2) const {
        return *s1 < *s2;
      }
    };
 
    typedef std::map<const std::string *, OksObject *, SortById> SMap;
 
 
    typedef std::unordered_map<const std::string *, OksObject *, oks::hash_str, oks::equal_str> Map;
    typedef std::unordered_set<OksObject *, oks::hash_obj_ptr, oks::equal_obj_ptr> FSet;
 
 
    typedef std::set<OksObject *, std::less<OksObject *> > Set;
 
    typedef std::list<OksObject *> List;
 
    typedef std::list<OksObject *, boost::fast_pool_allocator<OksObject *> > FList;
 
 
    OksObject (const OksClass * oks_class, const char * object_id = 0, bool skip_init = false);
 
 
    OksObject (const OksObject & parent_object, const char * object_id = 0);
 
 
    static void destroy(OksObject * obj, bool fast = false);
 
 
    bool operator==(const OksObject&) const;
 
 
    static bool
    are_equal_fast(const OksObject * o1, const OksObject * o2);
 
    bool operator!=(const OksObject&) const = delete;
 
 
    void * operator new(size_t) {return boost::fast_pool_allocator<OksObject>::allocate();}
 
 
    void operator delete(void *ptr) {boost::fast_pool_allocator<OksObject>::deallocate(reinterpret_cast<OksObject*>(ptr));}
 
 
    friend std::ostream& operator<<(std::ostream& out, const OksObject & obj);
 
 
    friend std::ostream& operator<<(std::ostream&, const OksObject *);
 
 
    const OksClass * GetClass() const {return uid.class_id;}
 
 
    const std::string& GetId() const {return uid.object_id;}
 
 
    void set_id(const std::string & id);
 
 
    OksFile * get_file() const {return file;}
 
 
    void set_file(OksFile * file, bool update_owner = true);
 
 
     OksData * GetAttributeValue(const std::string& name) const;
 
 
    OksData * GetAttributeValue(const OksDataInfo *i) const noexcept { return &(data[i->offset]); }
 
 
    OksData * GetRelationshipValue(const std::string&) const;
 
 
    OksData * GetRelationshipValue(const OksDataInfo *i) const noexcept { return &(data[i->offset]); }
 
 
    void SetAttributeValue(const std::string& name, OksData * data);
 
 
    void SetAttributeValue(const OksDataInfo * data_info, OksData * data);
 
 
    void SetRelationshipValue(const std::string& name, OksData * data, bool skip_non_null_check = false);
 
 
    void SetRelationshipValue(const OksDataInfo * data_info, OksData * data, bool skip_non_null_check = false);
 
 
    void SetRelationshipValue(const std::string& name, OksObject * object);
 
 
    void SetRelationshipValue(const OksDataInfo * data_info, OksObject * object);
 
 
    void AddRelationshipValue(const std::string& name, OksObject * object);
 
 
    void AddRelationshipValue(const OksDataInfo * data_info, OksObject * object);
 
 
    void RemoveRelationshipValue(const std::string& name, OksObject * object);
 
 
    void RemoveRelationshipValue(const OksDataInfo * data_info, OksObject * object);
 
 
    void SetRelationshipValue(const std::string& rel_name, const std::string& class_name, const std::string& object_id);
 
 
    void AddRelationshipValue(const std::string& rel_name, const std::string& class_name, const std::string& object_i);
 
 
    void RemoveRelationshipValue(const std::string& rel_name, const std::string& class_name, const std::string& object_i);
 
 
    const std::list<OksRCR *> * reverse_composite_rels() const {return p_rcr;}
 
 
    FList * get_all_rels(const std::string& name = "*") const;
 
 
    void SetTransientData(void *d) const {p_user_data = d;}
 
 
    void * GetTransientData() const {return p_user_data;}
 
 
    void set_int32_id(int32_t object_id) {p_int32_id = object_id;}
    
    int32_t get_int32_id() const  {return p_int32_id;}
 
    
 
    bool SatisfiesQueryExpression(OksQueryExpression * query_exp) const;
 
    bool satisfies(const OksObject * goal, const oks::QueryPathExpression& expresssion, OksObject::List& path) const;
    OksObject::List * find_path(const oks::QueryPath& query) const;
 
    bool is_consistent(const std::set<OksFile *>&, const char * msg) const;
 
     
    std::string report_dangling_references() const;
 
    void references(OksObject::FSet& refs, unsigned long recursion_depth, bool add_self = false, oks::ClassSet * classes = 0) const;
 
 
    bool is_duplicated() const { return (p_duplicated_object_id_idx != -1); }
 
 
  private:
 
      // the struct OksUid is used to describe object unique identity
      // in form 'class_name@object_identity'
 
    struct OksUid {
      const OksClass * class_id;
      std::string object_id;
 
      OksUid() : class_id(0) {;}
    } uid;
 
    OksData * data;
    std::list<OksRCR *> * p_rcr;
    mutable void * p_user_data;
    int32_t p_int32_id;
    int32_t p_duplicated_object_id_idx;
    OksFile * file;
 
 
      // to be used by OksKernel only
 
    ~OksObject();
 
 
    static OksObject * read(const oks::ReadFileParams&);
    void __report_type_cvt_warning(const oks::ReadFileParams&, const OksAttribute&, const OksData&, const OksData::Type, int32_t) const;
    void __report_cardinality_cvt_warning(const oks::ReadFileParams&, const OksRelationship&) const;
    int32_t __get_num(const oks::ReadFileParams& params);
 
 
 
      // these two are used by read() method
 
    void read_body(const oks::ReadFileParams&, bool);
 
    OksObject (const oks::ReadFileParams&, OksClass *, const std::string&);
 
 
 
      // to be used by OksIndex only
 
    OksObject (size_t, const OksData *);
 
      // to be used by OksKernel only
 
    OksObject (OksClass * c, const std::string& id, void * user_data, int32_t object_id, int32_t duplicated_object_id_idx, OksFile * f);
 
      // is not implemented and must not be used
 
    OksObject&  operator= (const OksObject &);
 
 
      // these 3 methods are used by constructors
 
    void init1(const OksFile * = 0);
    void init2(bool skip_init = false);
    void init3();
    void init3(OksClass *c);
 
    void check_ids();
 
 
  public:
 
    void add_RCR(OksObject *, const OksRelationship *);
    void remove_RCR(OksObject *, const OksRelationship *) noexcept;
 
 
  private:
 
    inline void notify() {
      file->set_updated();
      change_notify();
    }
 
    void check_class_type(const OksRelationship *, const OksClass *);
    void check_class_type(const OksRelationship *r, const OksObject *o) { if(o) { check_class_type(r, o->GetClass()); }}
    void check_non_null(const OksRelationship *, const OksObject *);
    void check_file_lock(const OksAttribute *, const OksRelationship *);
 
 
    void set_unique_id();
    void put(OksXmlOutputStream&, bool force_defaults) const;
    static void put_object_attributes(OksXmlOutputStream&, const OksData&);
 
      // bind data and methods
 
    struct BindInfo {
      OksKernel *       k;
      OksObject *       o;
      OksRelationship * r;
    };
 
    void            bind_objects();
    static void         bind(OksData *, const BindInfo&);
 
    void            unbind_file(const OksFile *);
 
 
      // check and report to standard out missing file inclusion paths
 
    bool check_links_and_report(const OksObject *, const std::set<OksFile *>&, const std::string&, const char *) const;
 
 
      // valid names of xml tags and attributes
 
    static const char       obj_xml_tag[];
    static const char       obj2_xml_tag[];
    static const char       attribute_xml_tag[];
    static const char       relationship_xml_tag[];
    static const char       class_xml_attribute[];
    static const char       class2_xml_attribute[];
    static const char       id_xml_attribute[];
    static const char       id2_xml_attribute[];
    static const char       name_xml_attribute[];
    static const char       type_xml_attribute[];
    static const char       num_xml_attribute[];
 
    static const char           value_xml_attribute[];
    static const char           data_xml_tag[];
    static const char           ref_xml_tag[];
 
    notify_obj          get_change_notify() const;
 
    void            create_notify();
    void            change_notify();
    void            delete_notify();
 
};
 
} // namespace oks
} // namespace dunedaq
 
#endif