dunedaq::oks::OksObject Class Reference

OksObject describes instance of OksClass. More...

#include <object.hpp>

Collaboration diagram for dunedaq::oks::OksObject:

Classes
struct	BindInfo
struct	OksUid
struct	SortById

Public Types
typedef void(*)	notify_obj(OksObject *, void *)
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

Public Member Functions
	OksObject (const OksClass *oks_class, const char *object_id=0, bool skip_init=false)
	OKS object constructor.
	OksObject (const OksObject &parent_object, const char *object_id=0)
	OKS object copy constructor.
bool	operator== (const OksObject &) const
	The equality operator.
bool	operator!= (const OksObject &) const =delete
void *	operator new (size_t)
void	operator delete (void *ptr)
const OksClass *	GetClass () const
const std::string &	GetId () const
void	set_id (const std::string &id)
	Set object ID.
OksFile *	get_file () const
void	set_file (OksFile *file, bool update_owner=true)
	Move object to different file.
OksData *	GetAttributeValue (const std::string &name) const
	Get value of attribute by name.
OksData *	GetAttributeValue (const OksDataInfo *i) const noexcept
	Get value of attribute by offset.
OksData *	GetRelationshipValue (const std::string &) const
	Get value of relationship by name.
OksData *	GetRelationshipValue (const OksDataInfo *i) const noexcept
	Get value of relationship by offset.
void	SetAttributeValue (const std::string &name, OksData *data)
	Set value of attribute by name.
void	SetAttributeValue (const OksDataInfo *data_info, OksData *data)
	Set value of attribute by offset.
void	SetRelationshipValue (const std::string &name, OksData *data, bool skip_non_null_check=false)
	Set value of relationship by name.
void	SetRelationshipValue (const OksDataInfo *data_info, OksData *data, bool skip_non_null_check=false)
	Set value of relationship by offset.
void	SetRelationshipValue (const std::string &name, OksObject *object)
	Set value of single-value relationship by name.
void	SetRelationshipValue (const OksDataInfo *data_info, OksObject *object)
	Set value of single-value relationship by offset.
void	AddRelationshipValue (const std::string &name, OksObject *object)
	Add object value to multi-value relationship by name.
void	AddRelationshipValue (const OksDataInfo *data_info, OksObject *object)
	Add object value to multi-value relationship by offset.
void	RemoveRelationshipValue (const std::string &name, OksObject *object)
	Remove object value from multi-value relationship by name.
void	RemoveRelationshipValue (const OksDataInfo *data_info, OksObject *object)
	Remove object value from multi-value relationship by offset.
void	SetRelationshipValue (const std::string &rel_name, const std::string &class_name, const std::string &object_id)
	Set class-name and object-id value of single-value relationship by name.
void	AddRelationshipValue (const std::string &rel_name, const std::string &class_name, const std::string &object_i)
	Add class-name and object-id value to multi-value relationship by name.
void	RemoveRelationshipValue (const std::string &rel_name, const std::string &class_name, const std::string &object_i)
	Remove class-name and object-id value from multi-value relationship by name.
const std::list< OksRCR * > *	reverse_composite_rels () const
	Return information about composite parents. The method returns list of the OKS object's reverse composite relationships.
FList *	get_all_rels (const std::string &name="*") const
	Return objects referencing this one via relationship with given name.
void	SetTransientData (void *d) const
	Set transient user data associated with given object. Such data are not stored on file and only exist while OksKernel object is not destroyed.
void *	GetTransientData () const
	Get transient user data associated with given object. Return data set using SetTransientData() method.
void	set_int32_id (int32_t object_id)
	Set object id is used to assign an object unique integer number. Such data are not stored on file and only exist while OksKernel object is not destroyed.
int32_t	get_int32_id () const
	Get object id associated with given object. Return integer number set using set_int32_id() method.
bool	SatisfiesQueryExpression (OksQueryExpression *query_exp) const
	Check if object satisfies query expression.
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
void	add_RCR (OksObject *, const OksRelationship *)
void	remove_RCR (OksObject *, const OksRelationship *) noexcept

Static Public Member Functions
static void	destroy (OksObject *obj, bool fast=false)
	Destroy OKS object.
static bool	are_equal_fast (const OksObject *o1, const OksObject *o2)
	The fast equal method.

Private Member Functions
	~OksObject ()
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)
void	read_body (const oks::ReadFileParams &, bool)
	OksObject (const oks::ReadFileParams &, OksClass *, const std::string &)
	OksObject (size_t, const OksData *)
	OksObject (OksClass *c, const std::string &id, void *user_data, int32_t object_id, int32_t duplicated_object_id_idx, OksFile *f)
OksObject &	operator= (const OksObject &)
void	init1 (const OksFile *=0)
void	init2 (bool skip_init=false)
void	init3 ()
void	init3 (OksClass *c)
void	check_ids ()
void	notify ()
void	check_class_type (const OksRelationship *, const OksClass *)
void	check_class_type (const OksRelationship *r, const OksObject *o)
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
void	bind_objects ()
void	unbind_file (const OksFile *)
bool	check_links_and_report (const OksObject *, const std::set< OksFile * > &, const std::string &, const char *) const
notify_obj	get_change_notify () const
void	create_notify ()
void	change_notify ()
void	delete_notify ()

Static Private Member Functions
static OksObject *	read (const oks::ReadFileParams &)
static void	put_object_attributes (OksXmlOutputStream &, const OksData &)
static void	bind (OksData *, const BindInfo &)

Private Attributes
struct dunedaq::oks::OksObject::OksUid	uid
OksData *	data
std::list< OksRCR * > *	p_rcr
void *	p_user_data
int32_t	p_int32_id
int32_t	p_duplicated_object_id_idx
OksFile *	file

Static Private Attributes
static const char	obj_xml_tag [] = "obj"
static const char	obj2_xml_tag [] = "o"
static const char	attribute_xml_tag [] = "attr"
static const char	relationship_xml_tag [] = "rel"
static const char	class_xml_attribute [] = "class"
static const char	class2_xml_attribute [] = "c"
static const char	id_xml_attribute [] = "id"
static const char	id2_xml_attribute [] = "i"
static const char	name_xml_attribute [] = "name"
static const char	type_xml_attribute [] = "type"
static const char	num_xml_attribute [] = "num"
static const char	value_xml_attribute [] = "val"
static const char	data_xml_tag [] = "data"
static const char	ref_xml_tag [] = "ref"

Friends
class	OksClass
struct	OksData
class	OksKernel
class	OksIndex
class	OksObjectSortBy
struct	OksLoadObjectsJob
struct	oks::ReadFileParams
struct	oks::ReloadObjects
std::ostream &	operator<< (std::ostream &out, const OksObject &obj)
	Detailed stream operator.
std::ostream &	operator<< (std::ostream &s, const OksObject *o)
	Short stream operator.

Detailed Description

OksObject describes instance of OksClass.

This class implements OKS object that is an instance of OKS class. Each object has unique ID string in a scope of class and its derived sub-classes. The properties of object are described by values of its attributes (i.e. values of primitive types like strings, integers, floats, see also OksAttribute) and relationships (i.e. references on others OKS objects, see also OksRelationship).

Definition at line 835 of file object.hpp.

Member Typedef Documentation

FList

std::list<OksObject *, boost::fast_pool_allocator<OksObject *> > dunedaq::oks::OksObject::FList

Definition at line 877 of file object.hpp.

FSet

std::unordered_set<OksObject *, oks::hash_obj_ptr, oks::equal_obj_ptr> dunedaq::oks::OksObject::FSet

Definition at line 866 of file object.hpp.

List

std::list<OksObject *> dunedaq::oks::OksObject::List

List of pointers to OksObject

Definition at line 875 of file object.hpp.

Map

std::unordered_map<const std::string *, OksObject *, oks::hash_str, oks::equal_str> dunedaq::oks::OksObject::Map

Map of pointers to OksObject (unsorted)

Definition at line 865 of file object.hpp.

notify_obj

void(*) dunedaq::oks::OksObject::notify_obj(OksObject *, void *)

Definition at line 848 of file object.hpp.

Set

std::set<OksObject *, std::less<OksObject *> > dunedaq::oks::OksObject::Set

Set of pointers to OksObject

Definition at line 871 of file object.hpp.

SMap

std::map<const std::string *, OksObject *, SortById> dunedaq::oks::OksObject::SMap

Map of pointers to OksObject sorted by object Id

Definition at line 860 of file object.hpp.

Constructor & Destructor Documentation

OksObject() [1/5]

dunedaq::oks::OksObject::OksObject	(	const OksClass *	oks_class,
		const char *	object_id = 0,
		bool	skip_init = false )

OKS object constructor.

Create new OKS object providing class and object ID. If the object ID is not set, the OKS creates new object with random unique ID. To create a new object the OKS kernel active data file has to be set.

In case of problems the error message is printed and the uid.class_id is set to 0 to flag the error.

The parameters are:

Parameters

oks_class	pointer to OKS class
object_id	optional object unique ID
skip_init	if true, skip initialization of OKS data

Definition at line 1175 of file object.cpp.

                                                                             : data(nullptr), p_duplicated_object_id_idx(-1)
{
  OSK_PROFILING(OksProfiler::ObjectNormalConstructor, c->p_kernel)
 
  if(!c->p_kernel->get_active_data()) {
    Oks::error_msg("OksObject::OksObject(const OksClass*, const char *)") << "  Can not create new object since there is no active data file\n";
    return;
  }
 
  uid.class_id = c;
  uid.object_id = (object_id ? object_id : "");
 
  try {
    init1();
  }
  catch(oks::exception& ex) {
    uid.class_id = nullptr;
    throw;
  }
 
  init2(skip_init);
  init3();
 
  file->set_updated();
}

OksObject() [2/5]

dunedaq::oks::OksObject::OksObject	(	const OksObject &	parent_object,
		const char *	object_id = 0 )

OKS object copy constructor.

Create new OKS object as copy of parent. If the object ID is not set, the OKS creates new object with random unique ID. To create a new object the OKS kernel active data file has to be set.

In case of problems the error message is printed and the uid.class_id is set to 0 to flag the error.

The parameters are:

Parameters

parent_object	pointer to OKS class
object_id	optional object unique ID

Definition at line 1201 of file object.cpp.

                                                                      : data(nullptr), p_duplicated_object_id_idx(-1)
{
  OSK_PROFILING(OksProfiler::ObjectCopyConstructor, parentObj.uid.class_id->p_kernel)
 
  if(!parentObj.uid.class_id->p_kernel->get_active_data()) {
    Oks::error_msg("OksObject::OksObject(const OksObject&, const char *)") << "  Can not create new object since there is no active data file\n";
    return;
  }
 
  const OksClass *c = uid.class_id = parentObj.uid.class_id;
 
  uid.object_id = (object_id ? object_id : "");
 
  try {
    init1();
  }
  catch(oks::exception& ex) {
    uid.class_id = nullptr;
    throw;
  }
 
  
  int count    = c->p_instance_size;
  int num_of_attr = c->p_all_attributes->size();
  int j    = 0;
 
  while(j < num_of_attr) {
    data[j] = parentObj.data[j];
    j++;
  }
 
  try {
    std::list<OksRelationship *>::iterator i = c->p_all_relationships->begin();
 
    while(j < count) {
      const OksRelationship * r = *i;
      const char * relationshipName = r->get_name().c_str();
 
      if(parentObj.data[j].type == OksData::list_type) {
        data[j].Set(new OksData::List());
                  
        if(parentObj.data[j].data.LIST) {
          for(const auto& i2 : *parentObj.data[j].data.LIST) {
            if(i2->type == OksData::object_type)
              AddRelationshipValue(relationshipName, i2->data.OBJECT);
            else {
              OksData * uid_d = new OksData();
              uid_d = i2;
              data[j].data.LIST->push_back(uid_d);
            }
          }
        }
      }
      else {
        if(parentObj.data[j].type == OksData::object_type) {
          data[j].Set((OksObject *)0);
          SetRelationshipValue(relationshipName, parentObj.data[j].data.OBJECT);
        }
        else
          data[j] = parentObj.data[j];
      }
      ++j;
      ++i;
    }
  }
  catch(oks::exception& ex) {
    uid.class_id = nullptr;
    throw;
  }
  
  init3();
 
  file->set_updated();
}

~OksObject()

dunedaq::oks::OksObject::~OksObject ( )

private

Definition at line 1364 of file object.cpp.

{
  OksClass * c = const_cast<OksClass *>(uid.class_id);
  
  if(!c) {
    if(data) {
      delete [] data;
    }
  }
  else {
    OksKernel * k = c->p_kernel;
 
    OSK_PROFILING(OksProfiler::ObjectDestructor, k)
 
      TLOG_DEBUG(4) << "destroy object " << this;
 
    static std::mutex s_mutex;
    static std::set<OksObject *, std::less<OksObject *> > oset;
 
    if(k->p_close_all == false) {
      k->undefine(this);
      std::lock_guard lock(s_mutex);
      oset.insert(this);
    }
 
    delete_notify();
 
    if(data) {
      if(c->p_all_relationships && !c->p_all_relationships->empty()) {
        OksData *di = data + c->number_of_all_attributes();
 
        for(std::list<OksRelationship *>::iterator i = c->p_all_relationships->begin(); i != c->p_all_relationships->end(); ++i, ++di) {
          OksRelationship * r = *i;
 
          if(r->get_is_composite() == false || k->p_close_all == true) continue;
 
          OksData * d = di;
 
          if(d->type == OksData::object_type && d->data.OBJECT) {
            OksObject * o = d->data.OBJECT;
 
            if(!k->is_dangling(o)) {
              o->remove_RCR(this, r);
 
              bool delete_obj(r->get_is_dependent() && !o->p_rcr);
 
              if(delete_obj) {
                std::lock_guard lock(s_mutex);
                delete_obj = (oset.find(o) == oset.end());
              }
 
              if( delete_obj ) {
                delete o;
                d->data.OBJECT = nullptr;
              }
            }
          }
          else if(d->type == OksData::list_type && d->data.LIST) {
            for(const auto& i2 : *d->data.LIST) {
              if(i2->type == OksData::object_type && i2->data.OBJECT) {
                OksObject * o = i2->data.OBJECT;
 
                if(!k->is_dangling(o)) {
                  o->remove_RCR(this, r);
 
                  bool delete_obj(r->get_is_dependent() && !o->p_rcr);
 
                  if(delete_obj) {
                    std::lock_guard lock(s_mutex);
                    delete_obj = (oset.find(o) == oset.end());
                  }
 
                  if( delete_obj ) {
                    delete o;
                    i2->data.OBJECT = nullptr;
                  }
                }
              }
            }
          }
        }
      }
 
      if(c->p_indices) {
        for(const auto& i : *c->p_indices)
          i.second->remove_obj(this);
      }
 
      int count = c->p_instance_size;
      while(count--) data[count].Clear();
 
      delete[] data;
 
      if(k->p_close_all == false) {
        try {
          c->remove(this);
        }
        catch(oks::exception& ex) {
          Oks::error_msg("OksObject::~OksObject()") << ex.what() << std::endl;
        }
      }
    }
 
    if(p_rcr) {
      for(std::list<OksRCR *>::const_iterator i = p_rcr->begin(); i != p_rcr->end(); ++i) {
        delete *i;
      }
 
      delete p_rcr;
    }
 
    if(k->p_close_all == false) {
      std::lock_guard lock(s_mutex);
      oset.erase(this);
    }
  }
}

OksObject() [3/5]

dunedaq::oks::OksObject::OksObject ( const oks::ReadFileParams & read_params, OksClass * c, const std::string & id )

private

Construct OKS object from input stream.

Exceptions

oks::exception

is thrown in case of errors.

Definition at line 1152 of file object.cpp.

                                                                                            : data(nullptr), p_duplicated_object_id_idx(-1)
{
  if(c) {
    OSK_PROFILING(OksProfiler::ObjectStreamConstructor, c->p_kernel)
  }
 
  uid.object_id = id;
  uid.class_id = c;
 
  std::shared_lock lock(read_params.oks_kernel->p_schema_mutex);  // protect schema and all objects from changes
 
  if(c) {
    init1(read_params.f);  // can throw exception; to be caught by caller (i.e. OksKernel)
  }
 
  read_body(read_params, false);
 
  if(c) {
    init3(c);
  }
}

OksObject() [4/5]

dunedaq::oks::OksObject::OksObject ( size_t offset, const OksData * d )

private

Definition at line 1276 of file object.cpp.

                                                    : data(nullptr), p_duplicated_object_id_idx(-1)
{
  uid.class_id = nullptr;
  data = new OksData[offset+1];
  memcpy(static_cast<void *>(&data[offset]), static_cast<const void *>(d), sizeof(OksData));
}

OksObject() [5/5]

dunedaq::oks::OksObject::OksObject ( OksClass * c, const std::string & id, void * user_data, int32_t object_id, int32_t duplicated_object_id_idx, OksFile * f )

private

Definition at line 1283 of file object.cpp.

                                                                                                                                         :
  data            (new OksData[c->p_instance_size]),
  p_user_data     (user_data),
  p_int32_id      (int32_id),
  p_duplicated_object_id_idx (duplicated_object_id_idx),
  file            (f)
  
{
  uid.class_id = c;
  uid.object_id = id;
 
    // set OksData type to unknown
  if(size_t data_size = c->p_instance_size * sizeof(OksData*)) {
    bzero(data, data_size);
  }
}

Member Function Documentation

__get_num()

int32_t dunedaq::oks::OksObject::__get_num ( const oks::ReadFileParams & params )

private

Definition at line 502 of file object.cpp.

{
  char * __sanity;
  params.s.get_num_token('\"');
  int32_t num = static_cast<int32_t>(strtol(params.s.m_cvt_char->m_buf, &__sanity, 0));
  if(*__sanity != 0 || errno == ERANGE) OksXmlInputStream::__throw_strto("strtol", __sanity, params.s.m_cvt_char->m_buf, params.s.get_line_no(), params.s.get_line_pos());
  return num;
}

__report_cardinality_cvt_warning()

void dunedaq::oks::OksObject::__report_cardinality_cvt_warning ( const oks::ReadFileParams & params, const OksRelationship & r ) const

private

Definition at line 485 of file object.cpp.

{
  std::lock_guard lock(OksKernel::p_parallel_out_mutex);
  Oks::warning_msg(std::string("Read object \"") + GetId() + '@' + GetClass()->get_name() + '\"')
    << "  file: \"" << params.f->get_full_file_name() << "\" (line: " << params.s.get_line_no() << ", pos: " << params.s.get_line_pos() << ")\n"
       "  mismatch between relationship \"" << r.get_name() << "\" cardinality and its value (save data file with new schema)." << std::endl;
}

__report_type_cvt_warning()

void dunedaq::oks::OksObject::__report_type_cvt_warning ( const oks::ReadFileParams & params, const OksAttribute & a, const OksData & d, const OksData::Type type, int32_t num ) const

private

Definition at line 451 of file object.cpp.

{
  const char * type_str;
 
  switch (type) {
    case OksData::s8_int_type:     type_str = OksAttribute::s8_int_type  ; break;
    case OksData::u8_int_type:     type_str = OksAttribute::u8_int_type  ; break;
    case OksData::s16_int_type:    type_str = OksAttribute::s16_int_type ; break;
    case OksData::u16_int_type:    type_str = OksAttribute::u16_int_type ; break;
    case OksData::s32_int_type:    type_str = OksAttribute::s32_int_type ; break;
    case OksData::u32_int_type:    type_str = OksAttribute::u32_int_type ; break;
    case OksData::s64_int_type:    type_str = OksAttribute::s64_int_type ; break;
    case OksData::u64_int_type:    type_str = OksAttribute::u64_int_type ; break;
    case OksData::float_type:      type_str = OksAttribute::float_type   ; break;
    case OksData::double_type:     type_str = OksAttribute::double_type  ; break;
    case OksData::bool_type:       type_str = OksAttribute::bool_type    ; break;
    case OksData::class_type:      type_str = OksAttribute::class_type   ; break;
    case OksData::date_type:       type_str = OksAttribute::date_type    ; break;
    case OksData::time_type:       type_str = OksAttribute::time_type    ; break;
    case OksData::string_type:     type_str = OksAttribute::string_type  ; break;
    case OksData::enum_type:       type_str = OksAttribute::enum_type    ; break;
    default:                       type_str = "unknown";
    
  }
 
  std::lock_guard lock(OksKernel::p_parallel_out_mutex);
  Oks::warning_msg(std::string("Read object \"") + GetId() + '@' + GetClass()->get_name() + '\"')
    << "  file: \"" << params.f->get_full_file_name() << "\" (line: " << params.s.get_line_no() << ", pos: " << params.s.get_line_pos() << ")\n"
       "  convert value from wrong type \"" << (num == -1 ? "single" : "multi") << "-value " << type_str << "\" to \"" << (a.get_is_multi_values() ? "multi" : "single")
    << "-value " << a.get_type() << "\" as required for attribute \"" << a.get_name() << "\"\n"
    << "  converted value: " << d << std::endl;
}

add_RCR()

void dunedaq::oks::OksObject::add_RCR	(	OksObject *	o,
		const OksRelationship *	r )

Definition at line 2574 of file object.cpp.

{
  if(r->get_is_composite() == false) return;
 
  TLOG_DEBUG(4) << "object " << this << " adds RCR to object " << o << " throught relationship \"" << r->get_name() << '\"';
 
  if(!p_rcr) {
    p_rcr = new std::list<OksRCR *>();
  }
  else {
    for(const auto& i : *p_rcr) {
      if(i->relationship == r) {
        if(i->obj == o) {
          TLOG_DEBUG(4) << "[this=" << this << ", o=" << o << ", r=\"" << r->get_name() << "\"]: such RCR was already set.";
          return;
          }
        else if(r->get_is_exclusive()) {
          throw oks::AddRcrError(this, r->get_name(), o, i->obj);
        }
      }
    }
  }
 
  p_rcr->push_back(new OksRCR(o, r));
}

AddRelationshipValue() [1/3]

void dunedaq::oks::OksObject::AddRelationshipValue	(	const OksDataInfo *	data_info,
		OksObject *	object )

Add object value to multi-value relationship by offset.

In case of problems (e.g. wrong class type, relationship is single-value or RCR cannot be set) the oks::exception is thrown.

The parameters are:

Parameters

data_info	describes offset of relationship's value for given OKS class
object	the object to be added

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2303 of file object.cpp.

{
  const OksRelationship * r = odi->relationship;
  size_t offset = odi->offset;
 
  if(!object) {
    throw oks::ObjectSetError(this, true, r->get_name(), "the (null) value is not allowed");
  }
 
  check_class_type(r, object);
 
  if( r->get_high_cardinality_constraint() != OksRelationship::Many ) {
    std::ostringstream text;
    text << "cannot add value " << object << " since the relationship has no \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  try {
    object->add_RCR(this, r);
  }
  catch(oks::exception& ex) {
    throw oks::ObjectSetError(this, true, r->get_name(), ex);
  }
 
  check_file_lock(0, r);
 
  data[offset].data.LIST->push_back(new OksData(object));
 
  notify();
}

AddRelationshipValue() [2/3]

void dunedaq::oks::OksObject::AddRelationshipValue	(	const std::string &	name,
		OksObject *	object )

Add object value to multi-value relationship by name.

In case of problems (e.g. no relationship with such name, wrong class type, relationship is single-value or RCR cannot be set) the oks::exception is thrown.

The parameters are:

Parameters

name	name of relationship
object	the object to be added

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2336 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  AddRelationshipValue(i->second, object);
}

AddRelationshipValue() [3/3]

void dunedaq::oks::OksObject::AddRelationshipValue	(	const std::string &	rel_name,
		const std::string &	class_name,
		const std::string &	object_i )

Add class-name and object-id value to multi-value relationship by name.

In case of problems (e.g. no relationship with such name, unknown class) the oks::exception is thrown.

The parameters are:

Parameters

rel_name	name of relationship
class_name	class name of the referenced object
object_id	ID of the referenced object

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2474 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
  
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  OksDataInfo * odi = i->second;
  const OksRelationship * r = odi->relationship;
 
  if(class_id.empty() || object_id.empty()) {
    throw oks::ObjectSetError(this, true, r->get_name(), "cannot add (null) object");
  }
 
  const std::string& r_class_type = r->get_type();
  size_t offset = odi->offset;
 
  OksClass *c = uid.class_id->p_kernel->find_class(class_id);
 
  if(c) {
    check_class_type(r, c);
  }
  else if(r_class_type != class_id) {
    std::ostringstream text;
    text << "cannot add value \"" << object_id << '@' << class_id << "\" since the class \"" << class_id
         << "\" is not defined and it is impossible to check its validity for given type of relationship";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  if(r->get_high_cardinality_constraint() != OksRelationship::Many) {
    std::ostringstream text;
    text << "cannot add object \"" << object_id << '@' << class_id << "\" since the relationship has no \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  OksObject *o = nullptr;
 
  if(c) o = c->get_object(object_id);
 
  if(o) {
    AddRelationshipValue(odi, o);
  }
  else {
    check_file_lock(0, r);
    data[offset].data.LIST->push_back(new OksData(class_id, object_id));
    notify();
  }
}

are_equal_fast()

bool dunedaq::oks::OksObject::are_equal_fast ( const OksObject * o1, const OksObject * o2 )

static

The fast equal method.

This method replaces operator!= used by OKS library in the past, since the operator causes problems starting from gcc62 assuming &reference != nullptr

The method returns false, if comparing objects belong to classes with different names or their IDs are not equal.

Definition at line 1600 of file object.cpp.

{
  if (o1 == o2)
    return true;
 
  if (o1 == nullptr || o2 == nullptr)
    return false;
 
  return (o1->uid.class_id->get_name() == o2->uid.class_id->get_name() && o1->uid.object_id == o2->uid.object_id);
}

bind()

void dunedaq::oks::OksObject::bind ( OksData * d, const BindInfo & info )

staticprivate

Definition at line 2626 of file object.cpp.

{
  const OksClass * c(0);
  OksObject * o(0);
 
  if(d->type == OksData::uid_type) {
    if(d->data.UID.class_id && !d->data.UID.object_id->empty()) {
      c = d->data.UID.class_id;
      o = c->get_object(d->data.UID.object_id);
    }
    else {
      d->Set((OksObject *)0);
      return;
    }
  }
  else {
    if(d->data.UID2.class_id->empty() || d->data.UID2.object_id->empty()) {
      d->Set((OksObject *)0);
      return;
    }
 
    c = info.k->find_class(*d->data.UID2.class_id);
 
    if(c) {
      o = c->get_object(d->data.UID2.object_id);
    }
    else {
      std::ostringstream text;
      text << "Class of object " << *d << " is not defined";
      throw oks::ObjectBindError(info.o, d, info.r, true, text.str(), "");
    }
  }
 
  if(c != info.r->p_class_type) {
    if(const OksClass::FList * slist = c->all_super_classes()) {
      for(OksClass::FList::const_iterator i = slist->begin(); i != slist->end(); ++i) {
        if(info.r->p_class_type == *i) {
          goto check_passed;
        }
      }
    }
 
    {
      std::ostringstream text;
      text << "The relationship has class type \"" << info.r->get_type() << "\" and the referenced object " << *d << " is not of that class or derived one";
      throw oks::ObjectBindError(info.o, d, info.r, true, text.str(), "");
    }
 
    check_passed: ;
  }
 
  if(!o) {
    std::ostringstream text;
    text << "Cannot find object " << *d;
    throw oks::ObjectBindError(info.o, d, info.r, false, text.str(), "");
  }
 
  try {
    d->Set(o);
    o->add_RCR(info.o, info.r);
  }
  catch(oks::exception& ex) {
    std::ostringstream text;
    text << "Failed to set relationship value " << o;
    throw oks::ObjectBindError(info.o, d, info.r, true, text.str(), ex);
  }
}

bind_objects()

void dunedaq::oks::OksObject::bind_objects ( )

private

Binds objects and returns true on success

Definition at line 2731 of file object.cpp.

{
  const OksClass * c = uid.class_id;
 
  if(c->p_all_relationships->empty()) return;  // if class has no relationships then nothing to do
 
  BindInfo info;
  info.k = c->p_kernel;
  info.o = this;
 
  OksData * d(data + c->number_of_all_attributes());
 
  BindWarning warnings;
 
  for (auto & i : (*c->p_all_relationships))
    {
      info.r = i;
 
      if(d->type == OksData::object_type)
        {
          if (i->get_low_cardinality_constraint() == OksRelationship::One && d->data.OBJECT == nullptr) { warnings.add(i); }
        }
      else if (d->type == OksData::uid_type)
        {
          if (d->data.UID.object_id == nullptr)
            {
              if (i->get_low_cardinality_constraint() == OksRelationship::One) { warnings.add(i); }
            }
 
          try
            {
              bind(d, info);
            }
          catch (oks::ObjectBindError& ex)
            {
              if (ex.p_is_error) { throw; }
              else { warnings.add(*ex.p_data, ex.p_rel); }
            }
        }
      else if (d->type == OksData::list_type)
        {
          if (d->data.LIST->empty())
            {
              if (i->get_low_cardinality_constraint() == OksRelationship::One) { warnings.add(i); }
            }
          else
            {
              for (const auto& i2 : *d->data.LIST)
                {
                  if (i2->type == OksData::uid_type || i2->type == OksData::uid2_type)
                    {
                      try
                        {
                          bind(i2, info);
                        }
                      catch (oks::ObjectBindError& ex)
                        {
                          if (ex.p_is_error) { throw; }
                          else { warnings.add(*ex.p_data, ex.p_rel); }
                        }
                    }
                }
            }
        }
      else if (d->type == OksData::uid2_type)
        {
          if (i->get_low_cardinality_constraint() == OksRelationship::One && d->data.UID2.object_id == nullptr) { warnings.add(i); }
          try
            {
              bind(d, info);
            }
          catch (oks::ObjectBindError& ex)
            {
              if (ex.p_is_error) { throw; }
              else { warnings.add(*ex.p_data, ex.p_rel); }
            }
        }
 
      d++;
    }
 
  if(warnings.p_warnings_count)
    {
      std::ostringstream text;
      const char * s1(warnings.p_warnings_count == 1 ? "is" : "are");
      const char * s2(warnings.p_warnings_count == 1 ? "" : "s");
      text << "There " << s1 << " " << warnings.p_warnings_count << " unresolved reference" << s2 << " from object " << this
           << '\n' << warnings.p_warnings->str();
      throw oks::ObjectBindError(this, 0, 0, false, text.str(), "");
    }
}

change_notify()

void dunedaq::oks::OksObject::change_notify ( )

private

Invoke change object notification.

Definition at line 2893 of file object.cpp.

{
  OksKernel * k = uid.class_id->p_kernel;
  if(k->p_change_object_notify_fn) {
    (*k->p_change_object_notify_fn)(this, k->p_change_object_notify_param);
  }
}

check_class_type() [1/2]

void dunedaq::oks::OksObject::check_class_type ( const OksRelationship * r, const OksClass * class_type )

private

Definition at line 2031 of file object.cpp.

{
  if(!class_type) return;
 
  const OksClass * rel_class_type = r->p_class_type;
 
  if(class_type != rel_class_type) {
    OksClass::FList * super_classes = class_type->p_all_super_classes;
 
    if(super_classes && !super_classes->empty()) {
      for(const auto& i : *super_classes) {
        if(rel_class_type == i) return;
      }
    }
 
    std::ostringstream text;
    text << "set to an object of class \"" << class_type->get_name() << "\" is not allowed since the relationship's class type is \""
         << r->get_type() << "\" and the class \"" << class_type->get_name() << "\" has no such superclass";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
}

check_class_type() [2/2]

void dunedaq::oks::OksObject::check_class_type ( const OksRelationship * r, const OksObject * o )

inlineprivate

Definition at line 1481 of file object.hpp.

{ if(o) { check_class_type(r, o->GetClass()); }}

check_file_lock()

void dunedaq::oks::OksObject::check_file_lock ( const OksAttribute * a, const OksRelationship * r )

private

Definition at line 3191 of file object.cpp.

{
  try {
    file->lock();
  }
  catch(oks::exception& ex) {
    throw oks::ObjectSetError(this, (a == nullptr), (a ? a->get_name() : r->get_name()), ex);
  }
}

check_ids()

void dunedaq::oks::OksObject::check_ids ( )

private

Definition at line 162 of file object.cpp.

{
  if (std::vector<OksClass *> * cs = uid.class_id->p_inheritance_hierarchy)
    {
      for (std::vector<OksClass *>::const_iterator j = cs->begin(); j != cs->end(); ++j)
        {
          OksObject * o = (*j)->get_object(uid.object_id);
          if (__builtin_expect((o != nullptr), 0))
            {
              std::stringstream e;
              e << "the object " << o << " from file \'" << o->get_file()->get_full_file_name() << "\' "
                  "has ID equal with \'" << uid.object_id << '@' << uid.class_id->get_name() << "\' object and their classes belong to the same inheritance hierarchy "
                  "(the OKS kernel is configured in the \"test-duplicated-objects-within-inheritance-hierarchy\" mode for compatibility with config and DAL tools)";
              throw oks::FailedCreateObject(this, e.str());
            }
        }
    }
}

check_links_and_report()

bool dunedaq::oks::OksObject::check_links_and_report ( const OksObject * o2, const std::set< OksFile * > & includes, const std::string & name, const char * msg ) const

private

Definition at line 2916 of file object.cpp.

{
  if(get_file() != o2->get_file()) {
    if(includes.find(o2->get_file()) == includes.end()) {
      if(GetClass()->get_kernel()->get_silence_mode() == false) {
        std::cerr <<
          msg << ": no files inclusion path between referenced objects:\n"
          "  object " << this << " from file \"" << get_file()->get_full_file_name() << "\" via relationship \"" << name << "\"\n"
          "  has reference to object " << o2 << " from file \"" << o2->get_file()->get_full_file_name() << "\";\n"
          "  file \"" << get_file()->get_full_file_name() << "\" includes " << includes.size() << " files:\n";
 
        for(std::set<OksFile *>::const_iterator j = includes.begin(); j != includes.end(); ++j) {
          std::cerr << "  * \'" << (*j)->get_full_file_name() << "\'\n"; 
        } 
        
      }
 
      return false;
    }
  }
  
  return true;
}

check_non_null()

void dunedaq::oks::OksObject::check_non_null ( const OksRelationship * r, const OksObject * o )

private

Definition at line 2019 of file object.cpp.

{
  if(!o && r->get_low_cardinality_constraint() != OksRelationship::Zero) {
    throw oks::ObjectSetError(
      this, true, r->get_name(),
      "set to (null) is not allowed since the relationship has non-zero low cardinality constraint"
    );
  }
}

create_notify()

void dunedaq::oks::OksObject::create_notify ( )

private

Invoke create object notification.

Definition at line 2879 of file object.cpp.

{
  OksKernel * k = uid.class_id->p_kernel;
 
  if(k->p_create_object_notify_fn) {
    (*k->p_create_object_notify_fn)(this, k->p_create_object_notify_param);
  }
}

delete_notify()

void dunedaq::oks::OksObject::delete_notify ( )

private

Invoke delete object notification.

Definition at line 2906 of file object.cpp.

{
  OksKernel * k = uid.class_id->p_kernel;
 
  if(k->p_delete_object_notify_fn) {
    (*k->p_delete_object_notify_fn)(this, k->p_delete_object_notify_param);
  }
}

destroy()

void dunedaq::oks::OksObject::destroy ( OksObject * obj, bool fast = false )

static

Destroy OKS object.

This the the only way available to user to destroy OKS object since ~OksObject() is private.

When an object is destroyed, it shall not be referenced by other objects.

In case of problems the oks::exception is thrown.

The parameters are:

Parameters

obj	the object to be destroyed
fast	if true, skip extra protection checks

Definition at line 1301 of file object.cpp.

{
  if(!o->uid.class_id || fast) {
    delete o;
    return;
  }
 
    // check lack of references on object
 
  std::unique_ptr<std::ostringstream> error_text;
 
  const OksClass::Map & classes = o->uid.class_id->p_kernel->classes();
 
  for(OksClass::Map::const_iterator i = classes.begin(); i != classes.end(); ++i) {
    OksClass *c(i->second);
    if(c->p_all_relationships == nullptr || c->p_all_relationships->empty()) continue;
 
    if(const OksObject::Map * objects = c->objects()) {
      for(OksObject::Map::const_iterator j = objects->begin(); j != objects->end(); ++j) {
        size_t offset = c->number_of_all_attributes();
        for(std::list<OksRelationship *>::iterator k = c->p_all_relationships->begin(); k != c->p_all_relationships->end(); ++k, ++offset) {
          OksData * d = j->second->data + offset;
          OksObject * ref = nullptr;
 
          if(d->type == OksData::object_type && d->data.OBJECT == o) {
            ref = j->second;
          }
          else if(d->type == OksData::list_type && d->data.LIST != nullptr) {
            for(const auto& l : *d->data.LIST) {
              if(l->type == OksData::object_type && l->data.OBJECT == o) {
                ref = j->second;
                break;
              }
            }
          }
 
          if(ref) {
            if(!error_text.get()) {
              error_text.reset(new std::ostringstream());
              *error_text << "since it is referenced by:";
            }
            *error_text << "\n   * object " << ref << " via relationship \"" << (*k)->get_name() << '\"';
          }
        }
      }
    }
  }
 
  if(error_text.get()) {
    throw oks::FailedDestoyObject(o, error_text->str().c_str());
  }
 
  try {
    o->file->lock();
    o->file->set_updated();
  }
  catch(oks::exception& ex) {
    throw oks::FailedDestoyObject(o, ex);
  }
 
  delete o;
}

find_path()

OksObject::List * dunedaq::oks::OksObject::find_path

(

const oks::QueryPath &

query

)

const

Definition at line 936 of file query.cpp.

{
  OksObject::List * path = new OksObject::List();
  
  if(satisfies(query.get_goal_object(), *query.get_start_expression(), *path) == false) {
    delete path;
    path = 0;
  }
 
  return path;
}

get_all_rels()

OksObject::FList * dunedaq::oks::OksObject::get_all_rels

(

const std::string &

name = "*"

)

const

Return objects referencing this one via relationship with given name.

The method returns list of objects which have a reference on given one. If the relationship name is set to "*", then the method takes into account all relationships of all objects. The method performs full scan of all OKS objects and it is not recommended at large scale to build complete graph of relations between all database object; if only composite parents are needed, them the reverse_composite_rels() method has to be used.

The parameters are:

Parameters

name	the name of relationship used to reference given object (by default ANY relationship)

Returns

the list of objects referencing this one (can be null, if there are no such objects); the user is responsible to destroy the returned list (but not the objects it contains)

Definition at line 3129 of file object.cpp.

{
  bool any_name = (name == "*");
  
  OksObject::FList * result = nullptr;
  
  const OksClass::Map& all_classes(GetClass()->get_kernel()->classes());
 
  for(OksClass::Map::const_iterator i = all_classes.begin(); i != all_classes.end(); ++i) {
    OksClass * c(i->second);
    if(any_name || c->find_relationship(name) != nullptr) {
      if(const OksObject::Map * objs = i->second->objects()) {
        for(OksObject::Map::const_iterator j = objs->begin(); j != objs->end(); ++j) {
          OksObject *o(j->second);
          unsigned short l1, l2;
          
          if(any_name) {
            l1 = c->number_of_all_attributes();
            l2 = l1 + c->number_of_all_relationships();
          }
          else {
            l1 = c->data_info(name)->offset;
            l2 = l1+1;
          }
 
          while(l1 < l2) {
            OksDataInfo odi(l1, (OksRelationship *)0);
            OksData * d(o->GetRelationshipValue(&odi));
 
            if(d->type == OksData::object_type) {
              if(this == d->data.OBJECT) {
                if(!result) result = new OksObject::FList();
                result->push_back(o);
                break;
              }
            }
            else if(d->type == OksData::list_type) {
              bool found = false;
              for(OksData::List::const_iterator li = d->data.LIST->begin(); li != d->data.LIST->end(); ++li) {
                OksData * lid(*li);
                if(lid->type == OksData::object_type) {
                  if(this == lid->data.OBJECT) {
                    if(!result) result = new OksObject::FList();
                    result->push_back(o);
                    found = true;
                    break; // exit given relationship value iterator
                  }
                }
              }
              if(found) break; //exit relationships iterator for given object
            }
            ++l1;
          }
        }
      }
    }
  }
  
  return result;
}

get_change_notify()

OksObject::notify_obj dunedaq::oks::OksObject::get_change_notify ( ) const

private

Definition at line 2869 of file object.cpp.

{
  return uid.class_id->p_kernel->p_change_object_notify_fn;
}

get_file()

OksFile * dunedaq::oks::OksObject::get_file ( ) const

inline

Get file of object.

Definition at line 1013 of file object.hpp.

{return file;}

get_int32_id()

int32_t dunedaq::oks::OksObject::get_int32_id ( ) const

inline

Get object id associated with given object. Return integer number set using set_int32_id() method.

Definition at line 1358 of file object.hpp.

{return p_int32_id;}

GetAttributeValue() [1/2]

OksData * dunedaq::oks::OksObject::GetAttributeValue ( const OksDataInfo * i ) const

inlinenoexcept

Get value of attribute by offset.

The method returns pointer on OksData value for given attribute offset. The method is optimised for performance and does not check validity of offset.

The parameter is:

Parameters

data_info

describes offset of attribute's value for given OKS class

Returns

the OKS data value for given attribute

Definition at line 1062 of file object.hpp.

{ return &(data[i->offset]); }

GetAttributeValue() [2/2]

OksData * dunedaq::oks::OksObject::GetAttributeValue

(

const std::string &

name

)

const

Get value of attribute by name.

The method returns pointer on OksData value for given attribute.

In case of problems (e.g. no attribute with such name) the oks::exception is thrown.

The parameter is:

Parameters

name	name of attribute

Returns

the OKS data value for given attribute

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 1919 of file object.cpp.

{
  OksDataInfo::Map::const_iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no attribute \"" << name << '\"';
    throw oks::ObjectGetError(this, false, name, text.str());
  }
 
  return GetAttributeValue(i->second);
}

GetClass()

const OksClass * dunedaq::oks::OksObject::GetClass ( ) const

inline

Get class of object.

Definition at line 990 of file object.hpp.

{return uid.class_id;}

GetId()

const std::string & dunedaq::oks::OksObject::GetId ( ) const

inline

Get object ID.

Definition at line 995 of file object.hpp.

{return uid.object_id;}

GetRelationshipValue() [1/2]

OksData * dunedaq::oks::OksObject::GetRelationshipValue ( const OksDataInfo * i ) const

inlinenoexcept

Get value of relationship by offset.

The method returns pointer on OksData value for given relationship offset. The method is optimised for performance and does not check validity of offset.

The parameter is:

Parameters

data_info

describes offset of relationship's value for given OKS class

Returns

the OKS data value for given relationship

Definition at line 1095 of file object.hpp.

{ return &(data[i->offset]); }

GetRelationshipValue() [2/2]

OksData * dunedaq::oks::OksObject::GetRelationshipValue

(

const std::string &

name

)

const

Get value of relationship by name.

The method returns pointer on OksData value for given relationship.

In case of problems (e.g. no relationship with such name) the oks::exception is thrown.

The parameter is:

Parameters

name	name of relationship

Returns

the OKS data value for given relationship

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2004 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
  
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectGetError(this, false, name, text.str());
  }
 
  return GetRelationshipValue(i->second);
}

GetTransientData()

void * dunedaq::oks::OksObject::GetTransientData ( ) const

inline

Get transient user data associated with given object. Return data set using SetTransientData() method.

Definition at line 1343 of file object.hpp.

{return p_user_data;}

init1()

void dunedaq::oks::OksObject::init1 ( const OksFile * fp = 0 )

private

Definition at line 182 of file object.cpp.

{
  const OksClass * c = uid.class_id;
  const std::string & object_id = uid.object_id;
  const OksKernel * kernel(c->get_kernel());
 
 
    // do not allow to create an object of ABSTRACT class
 
  if( __builtin_expect((c->get_is_abstract()), 0) ) {
    std::ostringstream text;
    text << "the class \'" << c->get_name() << "\' is abstract";
    throw oks::FailedCreateObject(this, text.str());
  }
 
 
    // do not allow two objects with equal ID in the same class
 
  if( __builtin_expect((!object_id.empty()), 1) ) {
    if (kernel->get_test_duplicated_objects_via_inheritance_mode() && !kernel->get_allow_duplicated_objects_mode()) {
      check_ids();
    }
 
    OksObject * o = c->get_object(object_id);
 
    if( __builtin_expect((o != nullptr), 0) ) {
      if(kernel->get_allow_duplicated_objects_mode()) {
        set_unique_id();
        if(kernel->get_silence_mode() != true) {
          std::cerr
            << "WARNING [OksObject constructor]:\n"
               "  Cannot create object " << o;
          if(fp) {
            std::cerr << " while reading file \'" << fp->get_full_file_name() << '\'';
          }
          std::cerr
            << "\n"
               "  Skip above problem since OKS kernel is configured in \'ignore-duplicated-objects\' mode\n"
            << "  Create duplicated object with ID = \'" << uid.object_id << "\'\n";
        }
      }
      else {
        std::stringstream e;
        e << "the object was already loaded from file \'" << o->get_file()->get_full_file_name() << '\'';
        throw oks::FailedCreateObject(this, e.str());
      }
    }
  }
  else {
      set_unique_id();
  }
 
  data = new OksData[c->p_instance_size];
  p_user_data = nullptr;
  p_int32_id = 0;
  p_rcr = nullptr;
  file = kernel->get_active_data();
}

init2()

void dunedaq::oks::OksObject::init2 ( bool skip_init = false )

private

Definition at line 275 of file object.cpp.

{
  int count = 0;
  const OksClass * c = uid.class_id;
 
  if (c->p_all_attributes)
    {
      if (skip_init == false)
        {
          for (const auto& i : *c->p_all_attributes)
            data[count++] = i->p_init_data;
        }
      else
        {
          for (const auto& i : *c->p_all_attributes)
            data[count++] = i->p_empty_init_data;
        }
    }
 
  if(c->p_all_relationships) {
    for(const auto& i : *c->p_all_relationships) {
      OksData& d(data[count++]);
      if(i->get_high_cardinality_constraint() != OksRelationship::Many) {
        d.type = OksData::object_type;
        d.data.OBJECT = nullptr;
      }
      else {
        d.type = OksData::list_type;
        d.data.LIST = new OksData::List();
      }
    }
  }
}

init3() [1/2]

void dunedaq::oks::OksObject::init3 ( )

private

Definition at line 321 of file object.cpp.

{
  init3(const_cast<OksClass *>(uid.class_id));
  create_notify();
}

init3() [2/2]

void dunedaq::oks::OksObject::init3 ( OksClass * c )

private

Definition at line 310 of file object.cpp.

{
  if( __builtin_expect((c->p_indices != nullptr), 0) ) {
    for(auto& i : *c->p_indices) i.second->insert(this);
  }
 
  c->add(this);
  c->p_kernel->define(this);
}

is_consistent()

bool dunedaq::oks::OksObject::is_consistent	(	const std::set< OksFile * > &	includes,
		const char *	msg ) const

The method checks the schema constraints for given object and the file's includes. Return false, if object is inconsistent.

Definition at line 2988 of file object.cpp.

{
  unsigned short l1 = GetClass()->number_of_all_attributes();
  unsigned short l2 = l1 + GetClass()->number_of_all_relationships();
 
  std::list<OksRelationship *>::const_iterator ri = GetClass()->all_relationships()->begin();
 
  bool return_value = true;
 
  while(l1 < l2) {
    OksDataInfo odi(l1, *ri);
    OksData * d(GetRelationshipValue(&odi));
 
    if(d->type == OksData::object_type) {
      if(OksObject * o2 = d->data.OBJECT) {
        check_links_and_report(o2, includes, odi.relationship->get_name(), msg);
      }
    }
    else if(d->type == OksData::list_type) {
      for(OksData::List::const_iterator li = d->data.LIST->begin(); li != d->data.LIST->end(); ++li) {
        if((*li)->type == OksData::object_type) {
          if(OksObject * o2 = (*li)->data.OBJECT) {
            check_links_and_report(o2, includes, odi.relationship->get_name(), msg);
          }
        }
      }
    }
 
    if(d->IsConsistent(odi.relationship, this, "ERROR") == false) {
      return_value = false;
    }
 
    ++l1;
    ++ri;
  }
 
    // check inclusion of the schema file
 
  if(includes.find(GetClass()->get_file()) == includes.end()) {
    if(GetClass()->get_kernel()->get_silence_mode() == false) {
      std::cerr <<
        "ERROR: the schema file is not included for object " << this << ".\n"
        "  The data file \"" << get_file()->get_full_file_name() << "\" containg above object\n"
        "  cannot be loaded or edited without inclusion of additional files.\n"
        "  The file shall explicitly or implicitly (i.e. via other included files) include schema file\n"
        "  \"" << GetClass()->get_file()->get_full_file_name() << "\" defining class \"" << GetClass()->get_name() << "\".\n";
    }
 
    return false;
  }
 
 
  return return_value;
}

is_duplicated()

bool dunedaq::oks::OksObject::is_duplicated ( ) const

inline

Definition at line 1390 of file object.hpp.

{ return (p_duplicated_object_id_idx != -1); }

notify()

void dunedaq::oks::OksObject::notify ( )

inlineprivate

Definition at line 1475 of file object.hpp.

                         {
      file->set_updated();
      change_notify();
    }

operator delete()

void dunedaq::oks::OksObject::operator delete ( void * ptr )

inline

Fast delete operator.

Definition at line 965 of file object.hpp.

{boost::fast_pool_allocator<OksObject>::deallocate(reinterpret_cast<OksObject*>(ptr));}

operator new()

void * dunedaq::oks::OksObject::operator new ( size_t )

inline

Fast new operator to reduce resources consumption.

Definition at line 960 of file object.hpp.

{return boost::fast_pool_allocator<OksObject>::allocate();}

operator!=()

bool dunedaq::oks::OksObject::operator!= ( const OksObject & ) const

delete

operator=()

OksObject & dunedaq::oks::OksObject::operator= ( const OksObject & )

private

operator==()

bool dunedaq::oks::OksObject::operator==

(

const OksObject &

o

)

const

The equality operator.

The operator returns true, if comparing objects belong to the same class or classes with equal names (e.g. belonging to different OksKernels) and their attributes and relationships are equal.

Definition at line 1612 of file object.cpp.

{
  if (are_equal_fast(this, &o) == false)
    return false;
 
  OSK_PROFILING(OksProfiler::ObjectOperatorEqual, uid.class_id->p_kernel)
 
  size_t count(0);
 
  while (count < uid.class_id->p_instance_size)
    {
      if (data[count] == o.data[count])
        count++;
      else
        return false;
    }
 
  return true;
}

put()

void dunedaq::oks::OksObject::put ( OksXmlOutputStream & xmls, bool force_defaults ) const

private

Definition at line 1780 of file object.cpp.

{
  OSK_PROFILING(OksProfiler::ObjectPutObject, uid.class_id->p_kernel)
 
  try
    {
      const OksClass * class_id = uid.class_id;
 
      xmls.put_start_tag(obj_xml_tag, sizeof(obj_xml_tag)-1);
 
      xmls.put_attribute(class_xml_attribute, sizeof(class_xml_attribute)-1, class_id->get_name().c_str());
      xmls.put_attribute(id_xml_attribute, sizeof(id_xml_attribute)-1, uid.object_id.c_str());
 
      xmls.put_eol();
 
      int count = 0;
 
      if (auto alist = class_id->all_attributes())
        {
          for (const auto& a : *alist)
            {
              OksData& d = data[count++];
 
              // store all attributes with value != initial, or date/time types which default values = now(), or non-numbers or numbers with non-zero values
              if (force_defaults || d != a->p_init_data || a->p_data_type == OksData::date_type || a->p_data_type == OksData::time_type || (a->get_init_value().empty() == false && (a->get_is_multi_values() == true || a->is_number() == false || a->get_init_value().size() > 1 || a->get_init_value()[0] != '0')))
                {
                  xmls.put_raw(' ');
                  xmls.put_start_tag(attribute_xml_tag, sizeof(attribute_xml_tag) - 1);
                  xmls.put_attribute(name_xml_attribute, sizeof(name_xml_attribute) - 1, a->get_name().c_str());
                  xmls.put_attribute(type_xml_attribute, sizeof(type_xml_attribute) - 1, a->get_type().c_str());
 
                  if (a->is_integer() && a->get_format() != OksAttribute::Dec)
                    {
                      xmls.get_stream().setf((a->get_format() == OksAttribute::Hex ? std::ios::hex : std::ios::oct), std::ios::basefield);
                      xmls.get_stream().setf(std::ios::showbase);
                    }
 
                  if (a->get_is_multi_values() == false)
                    {
                      xmls.put_attribute(value_xml_attribute, sizeof(value_xml_attribute) - 1, d);
                      xmls.put_end_tag();
                    }
                  else
                    {
                      if (d.data.LIST->empty())
                        {
                          xmls.put_end_tag();
                        }
                      else
                        {
                          if(a->p_ordered)
                            d.sort();
 
                          xmls.put_eol();
 
                          for (const auto& x : *d.data.LIST)
                            {
                              xmls.put_raw(' ');
                              xmls.put_raw(' ');
                              xmls.put_start_tag(data_xml_tag, sizeof(data_xml_tag) - 1);
                              xmls.put_attribute(value_xml_attribute, sizeof(value_xml_attribute) - 1, *x);
                              xmls.put_end_tag();
                            }
 
                          xmls.put_raw(' ');
                          xmls.put_last_tag(attribute_xml_tag, sizeof(attribute_xml_tag) - 1);
                        }
                    }
 
                  if (a->is_integer() && a->get_format() != OksAttribute::Dec)
                    {
                      xmls.get_stream().setf(std::ios::dec, std::ios::basefield);
                      xmls.get_stream().unsetf(std::ios::showbase);
                    }
                }
            }
        }
 
      if (const std::list<OksRelationship *> * rlist = class_id->all_relationships())
        {
          for (const auto& r : *rlist)
            {
              OksData& rel_data = data[count++];
 
              if (trim_dangling(rel_data, *class_id->p_kernel))
                {
                  xmls.put_raw(' ');
                  xmls.put_start_tag(relationship_xml_tag, sizeof(relationship_xml_tag) - 1);
                  xmls.put_attribute(name_xml_attribute, sizeof(name_xml_attribute) - 1, r->get_name().c_str());
 
                  if (r->get_high_cardinality_constraint() != OksRelationship::Many)
                    {
                      put_object_attributes(xmls, rel_data);
                      xmls.put_end_tag();
                    }
                  else
                    {
                      if(r->p_ordered)
                        rel_data.sort();
 
                      xmls.put_eol();
 
                      for (const auto& x : *rel_data.data.LIST)
                        {
                          xmls.put_raw(' ');
                          xmls.put_raw(' ');
                          xmls.put_start_tag(ref_xml_tag, sizeof(ref_xml_tag) - 1);
                          put_object_attributes(xmls, *x);
                          xmls.put_end_tag();
                        }
 
                      xmls.put_raw(' ');
                      xmls.put_last_tag(relationship_xml_tag, sizeof(relationship_xml_tag) - 1);
                    }
                }
            }
        }
 
      xmls.put_last_tag(obj_xml_tag, sizeof(obj_xml_tag) - 1);
    }
  catch (oks::exception & ex)
    {
      throw(oks::FailedSaveObject(this, ex));
    }
  catch (std::ios_base::failure & ex)
    {
      throw(oks::FailedSaveObject(this, std::string("caught std::ios_base::failure exception \"") + ex.what() + '\"'));
    }
  catch (std::exception & ex)
    {
      throw(oks::FailedSaveObject(this, std::string("caught std::exception \"") + ex.what() + '\"'));
    }
  catch (...)
    {
      throw(oks::FailedSaveObject(this, "unknown reason"));
    }
}

put_object_attributes()

void dunedaq::oks::OksObject::put_object_attributes ( OksXmlOutputStream & xmls, const OksData & d )

staticprivate

Definition at line 1754 of file object.cpp.

{
  const std::string * class_name = nullptr;
  const std::string * object_id = nullptr;
 
  if(d.type == OksData::object_type)
    {
      class_name = &d.data.OBJECT->GetClass()->get_name();
      object_id = &d.data.OBJECT->GetId();
    }
  else if(d.type == OksData::uid_type)
    {
      class_name = &d.data.UID.class_id->get_name();
      object_id = d.data.UID.object_id;
    }
  else
    {
      class_name = d.data.UID2.class_id;
      object_id = d.data.UID2.object_id;
    }
 
  xmls.put_attribute(class_xml_attribute, sizeof(class_xml_attribute)-1, class_name->c_str());
  xmls.put_attribute(id_xml_attribute, sizeof(id_xml_attribute)-1, object_id->c_str());
}

read()

OksObject * dunedaq::oks::OksObject::read ( const oks::ReadFileParams & read_params )

staticprivate

Read OKS object from input stream.

Returns

The method returns a pointer to OksObject, or NULL object to indicate end-of-stream.

Exceptions

oks::exception

is thrown in case of errors, e.g. bad input stream, duplicated object, abstract class of object.

Definition at line 363 of file object.cpp.

{
    // read 'object' tag header
 
  try {
    const char * tag_start(read_params.s.get_tag_start());
 
    if(memcmp(tag_start, read_params.object_tag, read_params.object_tag_len)) {
      if(!oks::cmp_str9(tag_start, "/oks-data")) {
        read_params.s.throw_unexpected_tag(tag_start, read_params.object_tag);
      }
      return 0;
    }
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("start-of-object tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("start-of-object tag", e.what());
  }
 
 
    // read object tag attributes
 
  OksClass * c(nullptr);
  std::string& id((const_cast<oks::ReadFileParams&>(read_params)).tmp);  // use temporal string for fast assignment
 
 
  try {
    if(read_params.format != 'c') {
      READ_OBJ_HEADER(oks::cmp_str5, class_xml_attribute, oks::cmp_str2, id_xml_attribute)
    }
    else {
      READ_OBJ_HEADER(oks::cmp_str1, class2_xml_attribute, oks::cmp_str1, id2_xml_attribute)
    }
  }
  catch(oks::exception & e) {
    throw oks::FailedRead("object header", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("object header", e.what());
  }
 
  if(!c) {
    throw oks::BadFileData("object without class", read_params.s.get_line_no(), read_params.s.get_line_pos());
  }
 
  try {
    oks::validate_not_empty(id, "object id");
  }
  catch(std::exception& ex) {
    throw oks::FailedRead("oks object", oks::BadFileData(ex.what(), read_params.s.get_line_no(), read_params.s.get_line_pos()));
  }
 
  if(c && read_params.reload_objects) {
    if(OksObject * o = read_params.reload_objects->pop(c, id)) {
      o->read_body(read_params, true);
      return o;
    }
  }
 
 
    // check if this is the end of file
 
  if(c == nullptr && id.empty()) { return nullptr; }
 
 
    // create new object
 
  OksObject * obj = new OksObject(read_params, c, id);  // can throw exception
 
 
    // check if we re-read the database and notify if required
 
  if(read_params.reload_objects) {
    read_params.reload_objects->created.push_back(obj);
    obj->create_notify();
 
    if(read_params.oks_kernel->get_verbose_mode()) {
      TLOG_DEBUG(3) << "*** create object " << obj << " while reload data ***";
    }
  }
 
  return obj;
}

read_body()

void dunedaq::oks::OksObject::read_body ( const oks::ReadFileParams & read_params, bool re_read )

private

Definition at line 513 of file object.cpp.

{
  std::string& i_name((const_cast<oks::ReadFileParams&>(read_params)).tmp);
  bool non_silent_mode(!read_params.oks_kernel->get_silence_mode());  // detect if we need to print errors
 
  OksData dd;                                         // temporal data
  const OksClass * c = uid.class_id;                  // pointer to object's class
 
  bool was_updated = false;                           // is used when object is re-read from file
  bool check_re_read = (re_read && read_params.oks_kernel->p_change_object_notify_fn);
 
  char * __sanity;                                    // used to check mu, token
 
 
    // set file from which this object was read
 
  file = read_params.f;
 
 
    // is used by ReadFrom(relationship)
 
  const_cast<oks::ReadFileParams&>(read_params).owner = this;
 
  if( __builtin_expect((read_params.format != 'c'), 1) ) {
    OksDataInfo::Map::iterator info_i;
    OksDataInfo * info(0);
 
 
      // are used when object is re-read from file
 
    std::list<const OksAttribute *> * read_attributes = nullptr;
    std::list<const OksRelationship *> * read_relationships = nullptr;
 
    if( __builtin_expect((check_re_read), 0) ) {
      if(c->p_all_attributes && !c->p_all_attributes->empty()) {
        read_attributes = new std::list<const OksAttribute *>();
        for(auto& i : *c->p_all_attributes)
          read_attributes->push_back(i);
      }
 
      if(c->p_all_relationships && !c->p_all_relationships->empty()) {
        read_relationships = new std::list<const OksRelationship *>();
        for(auto& i : *c->p_all_relationships)
          read_relationships->push_back(i);
      }
    }
    else if( __builtin_expect((c != nullptr), 1) ) {
      if( __builtin_expect((re_read == true), 0) ) {
        OksData *d_end = data + c->number_of_all_attributes() + c->number_of_all_relationships();
        for(OksData *di = data; di < d_end; ++di) {
          di->Clear();
        }
      }
 
      init2();
    }
 
 
      // read object body
 
    while(true) try {
 
      const char * tag_start = read_params.s.get_tag_start();
 
        // check for closing tag
 
      if(*tag_start == '/' && !memcmp(tag_start + 1, read_params.object_tag, read_params.object_tag_len)) { break; }
 
 
        // extra check, if the object is empty
 
      if(oks::cmp_str3(tag_start, "obj")) {
        read_params.s.seek_position(-5);
        break;
      }
 
 
        // read attribute
 
      else if(oks::cmp_str4(tag_start, attribute_xml_tag)) {
        OksData::Type type(OksData::unknown_type);
        int32_t num = -1; // -1 => no mv-data read
        const OksAttribute * a(0);
        OksXmlValue value;
        bool attr_is_closed(false);
 
          // read 'oks-attribute' tag attributes
 
        try {
 
          bool name_was_read(false);
 
          while(true) {
            OksXmlAttribute attr(read_params.s);
 
            // check for close of tag
            if(oks::cmp_str1(attr.name(), ">")) { break; }
 
            if(read_params.format == 'n' && oks::cmp_str1(attr.name(), "/"))
              {
                attr_is_closed = true;
                break;
              }
 
            // check for known oks-attribute' attributes
            if(oks::cmp_str4(attr.name(), name_xml_attribute)) {
              name_was_read = true;
              if( __builtin_expect((c != nullptr), 1) ) {
                i_name.assign(attr.value(), attr.value_len());
                info_i = c->p_data_info->find(i_name);
                if( __builtin_expect((info_i == c->p_data_info->end() || info_i->second->attribute == nullptr), 0) ) {
                  if(non_silent_mode) {
                    std::string msg = std::string("Read object \"") + GetId() + '@' + c->get_name() + '\"';
                    std::lock_guard lock(OksKernel::p_parallel_out_mutex);
                    Oks::warning_msg(msg.c_str()) << "  skip attribute \"" << attr.value() << "\", which is not defined in the schema\n";
                  }
                }
                else {
                  info = info_i->second;
                  a = info->attribute;
                }
              }
            }
            else if(oks::cmp_str4(attr.name(), type_xml_attribute)) {
              type = OksAttribute::get_data_type(attr.value(),attr.value_len());
              if( __builtin_expect((type == OksData::unknown_type), 0) ) {
                if(
                  attr.value()[0] != 0 &&
                  (
                    (attr.value()[0] == '-' && attr.value_len() != 1) ||
                    (attr.value()[0] != '-')
                  )
                ) {
                  __throw_unknown_type(read_params,attr.value());
                }
              }
            }
            else if(read_params.format != 'n' && oks::cmp_str3(attr.name(), num_xml_attribute)) {
              num = static_cast<int32_t>(strtol(attr.value(), &__sanity, 0));
              if( __builtin_expect((*__sanity != 0 || errno == ERANGE), 0) ) OksXmlInputStream::__throw_strto("strtoul", __sanity, attr.value(), read_params.s.get_line_no(), read_params.s.get_line_pos());
            }
            else if(read_params.format == 'n' && oks::cmp_str3(attr.name(), value_xml_attribute)) {
              value = read_params.s.get_value(attr.p_value_len);
            }
            else {
              read_params.s.throw_unexpected_attribute(attr.name());
            }
          }
 
          if( __builtin_expect((!name_was_read), 0) ) {
            throw oks::BadFileData("attribute without name", read_params.s.get_line_no(), read_params.s.get_line_pos());
          }
 
          if (read_params.format == 'n' && value.is_empty() == true)
            num = 0;
        }
        catch(oks::exception & e) {
          throw oks::FailedRead("attribute value header", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("attribute value header", e.what());
        }
 
        // read 'oks-attribute' body
        if( __builtin_expect((a != nullptr), 1) ) {
          OksData * d = &data[info->offset];
          OksData * dx;
 
          if( __builtin_expect((check_re_read), 0) ) {
            dx = &dd;
            read_attributes->remove(a);
          }
          else {
            dx = d;
          }
 
 
          // set default type if it was not read from file
          if( __builtin_expect((type == OksData::unknown_type), 0) ) {
            type = a->get_data_type();
          }
 
 
          try {
 
              // read value and convert if necessary
 
            if(num == -1) {
              if( __builtin_expect((a->get_data_type() != type || a->get_is_multi_values()), 0) ) {
                OksAttribute a2((type != OksData::enum_type ? type : OksData::string_type), c);
 
                OksData d2;
                if(read_params.format != 'n')
                  d2.read(read_params, &a2);
                else
                  d2.read(&a2, value);
                d2.cvt(dx, a);
                if(non_silent_mode) {
                  __report_type_cvt_warning(read_params, *a, *dx, type, num);
                }
              }
              else {
                if(read_params.format != 'n')
                  dx->read(read_params, a);
                else
                  dx->read(a, value);
              }
            }
            else {
              if( __builtin_expect((a->get_data_type() != type || !a->get_is_multi_values()), 0) ) {
                OksAttribute a2((type != OksData::enum_type ? type : OksData::string_type), c);
                OksData d2;
                if(read_params.format != 'n')
                  d2.read(read_params, &a2, num);
                else
                  {
                    if(attr_is_closed == false)
                      d2.read(&a2, read_params);
                    else
                      d2.Set(new OksData::List());
                  }
                d2.cvt(dx, a);
                if(non_silent_mode) {
                  __report_type_cvt_warning(read_params, *a, *dx, type, num);
                }
              }
              else {
                if(read_params.format != 'n')
                  dx->read(read_params, a, num);
                else
                  {
                  if(attr_is_closed == false)
                    dx->read(a, read_params);
                  else
                    dx->Set(new OksData::List());
                  }
              }
            }
 
              // check validity range
 
            dx->check_range(a);
          }
          catch (oks::exception & e) {
            throw oks::FailedReadObject(this, std::string("attribute \"") + a->get_name() + '\"', e);
          }
          catch (std::exception & e) {
            throw oks::FailedReadObject(this, std::string("attribute \"") + a->get_name() + '\"', e.what());
          }
 
 
          if( __builtin_expect((check_re_read), 0) ) {
            if(*dx != *d) {
              was_updated = true;
              *d = *dx;
            }
            dd.Clear();
          }
        }
        else {
          try {
            OksAttribute a2((type != OksData::enum_type ? type : OksData::string_type), c);
            if(num == -1) {
              // note, there is no need to read single-value in case of "normal" format
              if(read_params.format != 'n')
                OksData(read_params, &a2);
            }
            else {
              if(read_params.format != 'n')
                OksData(read_params, &a2, num);
              else
                OksData(&a2, read_params);
            }
          }
          catch (oks::exception & e) {
            throw oks::FailedReadObject(this, "dummu attribute", e);
          }
          catch (std::exception & e) {
            throw oks::FailedReadObject(this, "dummu attribute", e.what());
          }
        }
 
 
          // read 'oks-attribute' close tag
 
        if(read_params.format != 'n')
          try {
            const char * eoa_tag_start = read_params.s.get_tag_start();
 
            if(!oks::cmp_str5(eoa_tag_start, "/attr")) {
              std::string s("\'/attr\' is expected instead of \'");
              s += eoa_tag_start;
              s += '\'';
              throw std::runtime_error( s.c_str() );
            }
          }
          catch (oks::exception & e) {
            throw oks::FailedRead(std::string("attribute\'s closing tag"), e);
          }
          catch (std::exception & e) {
            throw oks::FailedRead(std::string("attribute\'s closing tag"), e.what());
          }
 
      }  // end of "read attribute"
 
 
        // read relationship
 
      else if(oks::cmp_str3(tag_start, relationship_xml_tag)) {
        int32_t num = -1; // -1 => no mv-data read
        OksRelationship * r(nullptr);
        OksXmlRelValue value(read_params);
 
          // read 'oks-relationship' tag attributes
 
        try {
          while(true) {
            OksXmlAttribute attr(read_params.s);
 
              // check for close of tag
 
            if(oks::cmp_str1(attr.name(), ">") || (read_params.format == 'n' && oks::cmp_str1(attr.name(), "/"))) { break; }
 
              // check for known oks-relationship' attributes
 
            else if(oks::cmp_str4(attr.name(), name_xml_attribute)) {
              if( __builtin_expect((c != nullptr), 1) ) {
                i_name.assign(attr.value(), attr.value_len());
                info_i = c->p_data_info->find(i_name);
                if( __builtin_expect((info_i == c->p_data_info->end() || info_i->second->relationship == nullptr), 0) ) {
                  if(non_silent_mode) {
                    std::string msg = std::string("Read object \"") + GetId() + '@' + c->get_name() + '\"';
                    std::lock_guard lock(OksKernel::p_parallel_out_mutex);
                    Oks::warning_msg(msg.c_str()) << "  skip relationship \"" << attr.value() << "\", which is not defined in the schema\n";
                  }
                }
                else {
                  info = info_i->second;
                  r = const_cast<OksRelationship *>(info->relationship);
                }
              }
              continue;
            }
            else if(read_params.format == 'n') {
              if(oks::cmp_str5(attr.name(), class_xml_attribute)) {
                value.m_class = uid.class_id->get_kernel()->find_class(attr.value());
                if( __builtin_expect((value.m_class == nullptr && attr.value_len() > 0), 0) ) {
                  value.m_class_id = new OksString(attr.value(), attr.value_len());
                }
                continue;
              }
              else if(oks::cmp_str2(attr.name(), id_xml_attribute)) {
                value.m_value = read_params.s.get_value(attr.p_value_len);
                continue;
              }
            }
            else {
              if(oks::cmp_str3(attr.name(), num_xml_attribute)) {
                num = static_cast<int32_t>(strtol(attr.value(), &__sanity, 0));
                if( __builtin_expect((*__sanity != 0 || errno == ERANGE), 0) ) OksXmlInputStream::__throw_strto("strtoul", __sanity, attr.value(), read_params.s.get_line_no(), read_params.s.get_line_pos());
                continue;
              }
            }
 
            read_params.s.throw_unexpected_attribute(attr.name());
          }
        }
        catch(oks::exception & e) {
          throw oks::FailedRead("relationship value header", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("relationship value header", e.what());
        }
 
        if (read_params.format == 'n' && value.is_empty() == true)
          num = 0;
 
          // read 'oks-relationship' body
 
        if( __builtin_expect((r != nullptr), 1) ) {
          OksData *d = &data[info->offset];
          OksData * dx;
 
          OksRelationship::CardinalityConstraint cc = r->get_high_cardinality_constraint();
 
          if( __builtin_expect((check_re_read), 0) ) {
            dx = &dd;
            read_relationships->remove(r);
          }
          else {
            dx = d;
          }
 
          try {
            if(num == -1) {
              if(cc == OksRelationship::Many) {
                __report_cardinality_cvt_warning(read_params, *r);
                OksRelationship dummy(*r);
                OksData d2;
                if(read_params.format == 'n')
                  d2.read(&dummy, value);
                else
                  d2.read(read_params, &dummy);
                d2.ConvertTo(dx, r);
              }
              else {
                if(read_params.format == 'n')
                  dx->read(r, value);
                else
                  dx->read(read_params, r);
              }
            }
            else {
              if(cc != OksRelationship::Many) {
                __report_cardinality_cvt_warning(read_params, *r);
                OksRelationship dummy(*r);
                OksData d2;
                if(read_params.format == 'n')
                  d2.read(&dummy, read_params);
                else
                  d2.read(read_params, &dummy, num);
                d2.ConvertTo(dx, r);
              }
              else {
                if(read_params.format == 'n')
                  dx->read(r, read_params);
                else
                  dx->read(read_params, r, num);
              }
            }
          }
          catch (oks::exception & e) {
            throw oks::FailedReadObject(this, std::string("relationship \"") + r->get_name() + '\"', e);
          }
          catch (std::exception & e) {
            throw oks::FailedReadObject(this, std::string("relationship \"") + r->get_name() + '\"', e.what());
          }
 
          if(check_re_read) {
            if(*dx != *d) {
              was_updated = true;
              *d = *dx;
            }
            dd.Clear();
          }
        }
        else {
          OksRelationship r("_ _ *** dummy *** _ _"); // temporal relationship to use right OksData constructor call
 
          try {
            if(num == -1) {
              if(read_params.format != 'n')
                OksData(read_params, &r);
            }
            else {
              if(read_params.format == 'n')
                OksData(&r, read_params);
              else
                OksData(read_params, &r, num);
            }
          }
          catch (oks::exception & e) {
            throw oks::FailedReadObject(this, "dummu relationship", e);
          }
          catch (std::exception & e) {
            throw oks::FailedReadObject(this, "dummu relationship", e.what());
          }
        }
 
 
          // read 'oks-relationship' close tag
 
        if(read_params.format != 'n')
          try {
            const char * eor_tag_start = read_params.s.get_tag_start();
 
            if(!oks::cmp_str4(eor_tag_start, "/rel")) {
              std::string s("\'/rel\' is expected instead of \'");
              s += eor_tag_start;
              s += '\'';
              throw std::runtime_error( s.c_str() );
            }
          }
          catch (oks::exception & e) {
            throw oks::FailedRead(std::string("relationship\'s closing tag"), e);
          }
          catch (std::exception & e) {
            throw oks::FailedRead(std::string("relationship\'s closing tag"), e.what());
          }
 
      }  // end of "read relationship"
 
    }
 
    catch (oks::exception & e) {
      throw oks::FailedRead(std::string("object \"") + uid.object_id + '@' + c->get_name() + '\"', e);
    }
    catch (std::exception & e) {
      throw oks::FailedRead(std::string("object \"") + uid.object_id + '@' + c->get_name() + '\"', e.what());
    }
 
 
      // check that unread attributes & relationships have default values
 
    if( __builtin_expect((check_re_read), 0) ) {
      if(read_attributes) {
        if(!read_attributes->empty()) {
          for(auto i = read_attributes->begin(); i != read_attributes->end(); i = read_attributes->erase(i)) {
            OksData d = (*i)->p_init_data;
            try {
              OksData *d2(GetAttributeValue((*i)->get_name()));
              if(*d2 != d) {
                *d2 = d;
                was_updated = true;
              }
            }
            catch(oks::exception& ex) {
              throw oks::ObjectInitError(this, std::string("cannot reset default value of attribute \"") + (*i)->get_name() + '\"', ex);
            }
          }
        }
 
        delete read_attributes;
      }
 
      if(read_relationships) {
        if(!read_relationships->empty()) {
          for(auto i = read_relationships->begin(); i != read_relationships->end(); i = read_relationships->erase(i)) {
            OksData d; d.ReadFrom(*i);
            try {
              OksData *d2(GetRelationshipValue((*i)->get_name()));
              if(d2 && *d2 != d) {
                *d2 = d;
                was_updated = true;
              }
            }
            catch(oks::exception& ex) {
              throw oks::ObjectInitError(this, std::string("cannot reset value of relationship \"") + (*i)->get_name() + '\"', ex);
            }
          }
        }
 
        delete read_relationships;
      }
    }
  }
  else {
    size_t count(0);
 
    if(c == 0) {
      throw std::runtime_error(
        "  *****     Can't read objects of undefined class     *****\n"
        "  *****    from file saved in non-extended format.    *****\n"
        "  ***** Fix the problem first. Processing terminated. *****\n"
      );
    }
 
    if(c->p_all_attributes) {
      for(const auto& i : *c->p_all_attributes) {
        if(check_re_read) {
          OksData d;
 
          if(i->get_is_multi_values()) {
            d.read(read_params, i, __get_num(read_params));
          }
          else {
            d.read(read_params, i);
          }
 
          if(d != data[count]) {
            data[count] = d;
            was_updated = true;
          }
        }
        else {
          if(i->get_is_multi_values()) {
            data[count].read(read_params, i, __get_num(read_params));
          }
          else {
            data[count].read(read_params, i);
          }
        }
 
        count++;
      }
    }
 
    if(c->p_all_relationships) {
      for(const auto& i : *c->p_all_relationships) {
        if(check_re_read) {
          OksData d;
 
          if(i->get_high_cardinality_constraint() == OksRelationship::Many) {
            d.read(read_params, i, __get_num(read_params));
          }
          else {
            d.read(read_params, i);
          }
 
          if(d != data[count]) {
            data[count] = d;
            was_updated = true;
          }
        }
        else {
          if(i->get_high_cardinality_constraint() == OksRelationship::Many) {
            data[count].read(read_params, i, __get_num(read_params));
          }
          else {
            data[count].read(read_params, i);
          }
        }
 
        count++;
      }
    }
 
      // read tag closing object
 
    try {
      const char * tag_start = read_params.s.get_tag_start();
    
      if(*tag_start != '/' || memcmp(tag_start + 1, read_params.object_tag, read_params.object_tag_len)) {
        std::ostringstream s;
        s << "Failed to read obj close tag (\'/" << read_params.object_tag << "\' is expected)";
        throw std::runtime_error( s.str().c_str() );
      }
    }
    catch (oks::exception & e) {
      throw oks::FailedRead("object close tag", e);
    }
    catch (std::exception & e) {
      throw oks::FailedRead("object close tag", e.what());
    }
  }
 
  if(was_updated) change_notify();
}

references()

void dunedaq::oks::OksObject::references	(	OksObject::FSet &	refs,
		unsigned long	recursion_depth,
		bool	add_self = false,
		oks::ClassSet *	classes = 0 ) const

The method puts to set objects recursively referenced by given object.

Definition at line 3110 of file object.cpp.

{
  struct RefData data(refs, classes);
 
  std::lock_guard lock(uid.class_id->p_kernel->p_objects_refs_mutex);
 
  OksObject::FSet tested_objs;
 
  if(add_self) {
    insert2refs(this, recursion_depth + 1, data);
  }
 
  _references(this, recursion_depth, data);
 
  TLOG_DEBUG(2) <<  "OksObject::references(" << this << ", " << recursion_depth << ") returns " << refs.size() << " objects";
}

remove_RCR()

void dunedaq::oks::OksObject::remove_RCR ( OksObject * o, const OksRelationship * r )

noexcept

Definition at line 2602 of file object.cpp.

{
  TLOG_DEBUG(4) << "object " << this << " removes RCR from object " << o << " through " << r->get_name();
 
  if(r->get_is_composite() == false || !p_rcr) return;
 
  for(std::list<OksRCR *>::iterator i = p_rcr->begin(); i != p_rcr->end(); ++i) {
    OksRCR *rcr = *i;
 
    if(rcr->obj == o && rcr->relationship == r) {
      p_rcr->erase(i);
      delete rcr;
      break;
    }
  }
 
  if(p_rcr->empty()) {
    delete p_rcr;
    p_rcr = nullptr;
  }
}

RemoveRelationshipValue() [1/3]

void dunedaq::oks::OksObject::RemoveRelationshipValue	(	const OksDataInfo *	data_info,
		OksObject *	object )

Remove object value from multi-value relationship by offset.

In case of problems (e.g. relationship is single-value or there is no such object) the oks::exception is thrown.

The parameters are:

Parameters

data_info	describes offset of relationship's value for given OKS class
object	the object to be removed from relationship

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2351 of file object.cpp.

{
  const OksRelationship * r = odi->relationship;
  
  if(!object) {
    throw oks::ObjectSetError(this, true, r->get_name(), "cannot remove (null) object");
  }
 
  if(r->get_high_cardinality_constraint() != OksRelationship::Many) {
    std::ostringstream text;
    text << "cannot remove object " << object << " since the relationship has no \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  OksData d(object);
  size_t offset = odi->offset;
  OksData::List * list = data[offset].data.LIST;
  
  for(OksData::List::iterator i = list->begin(); i != list->end();) {
    OksData * d2 = *i;
    if(cmp_data(d2, &d)) {
      check_file_lock(0, r);
      object->remove_RCR(this, r);
      list->erase(i);
      delete d2;
      notify();
      return;
    }
    else ++i;
  }
 
  std::ostringstream text;
  text << "cannot remove object " << object << " since the relationship\'s value has no such object";
  throw oks::ObjectSetError(this, true, r->get_name(), text.str());
}

RemoveRelationshipValue() [2/3]

void dunedaq::oks::OksObject::RemoveRelationshipValue	(	const std::string &	name,
		OksObject *	object )

Remove object value from multi-value relationship by name.

In case of problems (e.g. no relationship with such name, relationship is single-value or there is no such object) the oks::exception is thrown.

The parameters are:

Parameters

name	name of relationship
object	the object to be removed from relationship

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2389 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  RemoveRelationshipValue(i->second, object);
}

RemoveRelationshipValue() [3/3]

void dunedaq::oks::OksObject::RemoveRelationshipValue	(	const std::string &	rel_name,
		const std::string &	class_name,
		const std::string &	object_i )

Remove class-name and object-id value from multi-value relationship by name.

In case of problems (e.g. no relationship with such name, no such object) the oks::exception is thrown.

The parameters are:

Parameters

rel_name	name of relationship
class_name	class name of the referenced object
object_id	ID of the referenced object

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2528 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  OksDataInfo * odi = i->second;
  const OksRelationship * r = odi->relationship;
 
  if(object_id.empty() || class_id.empty()) {
    throw oks::ObjectSetError(this, true, r->get_name(), "cannot remove (null) object");
  }
 
  if( r->get_high_cardinality_constraint() != OksRelationship::Many ) {
    std::ostringstream text;
    text << "cannot remove object \"" << object_id << '@' << class_id << "\" since the relationship has no \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  size_t offset = odi->offset;
  OksData d(class_id, object_id);
  OksData::List * list = data[offset].data.LIST;
 
  for(OksData::List::iterator j = list->begin(); j != list->end();) {
    OksData * d2 = *j;
    if(cmp_data(d2, &d)) {
      check_file_lock(0, r);
      list->erase(j);
      delete d2;
      notify();
      return;
    }
    else ++j;
  }
 
  std::ostringstream text;
  text << "cannot remove object \"" << object_id << '@' << class_id << "\" since the relationship\'s value has no such object";
  throw oks::ObjectSetError(this, true, r->get_name(), text.str());
}

report_dangling_references()

std::string dunedaq::oks::OksObject::report_dangling_references

(

)

const

The method returns string containing dangling references for given object.

Definition at line 2957 of file object.cpp.

{
  unsigned short l1 = GetClass()->number_of_all_attributes();
  unsigned short l2 = l1 + GetClass()->number_of_all_relationships();
 
  std::list<OksRelationship *>::const_iterator ri = GetClass()->all_relationships()->begin();
 
  std::string result;
 
  while(l1 < l2) {
    OksDataInfo odi(l1, *ri);
    OksData * d(GetRelationshipValue(&odi));
 
    if(d->type == OksData::list_type) {
      for(OksData::List::const_iterator li = d->data.LIST->begin(); li != d->data.LIST->end(); ++li) {
        test_dangling_references(this, **li, **ri, result);
      }
    }
    else {
      test_dangling_references(this, *d, **ri, result);
    }
 
    ++l1;
    ++ri;
  }
 
  return result;
}

reverse_composite_rels()

const std::list< OksRCR * > * dunedaq::oks::OksObject::reverse_composite_rels ( ) const

inline

Return information about composite parents. The method returns list of the OKS object's reverse composite relationships.

Definition at line 1310 of file object.hpp.

{return p_rcr;}

satisfies()

bool dunedaq::oks::OksObject::satisfies	(	const OksObject *	goal,
		const oks::QueryPathExpression &	expresssion,
		OksObject::List &	path ) const

Definition at line 950 of file query.cpp.

{
    // check the object is not in the path
 
  {
    for(std::list<OksObject *>::const_iterator i = path.begin(); i != path.end(); ++i) {
      if(*i == this) return false;
    }
  }
 
  path.push_back(const_cast<OksObject *>(this));
 
 
  for(std::list<std::string>::const_iterator i = expression.get_rel_names().begin(); i != expression.get_rel_names().end(); ++i) {
    OksData * d = 0;
 
    if(!(*i).empty() && (*i)[0] == '?') {
      std::string nm = (*i).substr(1);
      OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(nm);
 
      if(i != uid.class_id->p_data_info->end()) {
        d = GetRelationshipValue((*i).second);
      }
      else {
        continue;
      }
    }
    else {
      try {
        d = GetRelationshipValue(*i);
      }
      catch(oks::exception& ex) {
        Oks::error_msg("OksObject::satisfies") << ex.what() << std::endl;
        continue;
      }
    }
 
      // check if given relationship points to destination object
 
    if(d->type == OksData::object_type && d->data.OBJECT == goal) return true;
    else if(d->type == OksData::list_type && d->data.LIST) {
      for(OksData::List::iterator i2 = d->data.LIST->begin(); i2 != d->data.LIST->end(); ++i2) {
        OksData * d2 = (*i2);
        if(d2->type == OksData::object_type && d2->data.OBJECT == goal) return true;
      }
    }
 
 
      // go to next path, if there are no more expressions
 
    if(!expression.get_next()) {
      continue;
    }
 
 
      // check, if there is need for nested path lookup
 
    else if(expression.get_use_nested_lookup()) {
 
        // go directly
 
      path.pop_back();
      if(satisfies(goal, *expression.get_next(), path) == true) return true;
      path.push_back(const_cast<OksObject *>(this));
 
        // go nested
 
      if(d->type == OksData::object_type && d->data.OBJECT) {
        if(d->data.OBJECT->satisfies(goal, expression, path) == true) return true;
      }
      else if(d->type == OksData::list_type && d->data.LIST) {
        for(OksData::List::iterator i2 = d->data.LIST->begin(); i2 != d->data.LIST->end(); ++i2) {
          OksData * d2 = (*i2);
          if(d2->type == OksData::object_type && d2->data.OBJECT) {
            if(d2->data.OBJECT->satisfies(goal, expression, path) == true) return true;
      }
        }
      }
    }
 
    else {
      if(d->type == OksData::object_type && d->data.OBJECT) {
        if(d->data.OBJECT->satisfies(goal, *expression.get_next(), path) == true) return true;
      }
      else if(d->type == OksData::list_type && d->data.LIST) {
        for(OksData::List::iterator i2 = d->data.LIST->begin(); i2 != d->data.LIST->end(); ++i2) {
          OksData * d2 = (*i2);
          if(d2->type == OksData::object_type && d2->data.OBJECT) {
            if(d2->data.OBJECT->satisfies(goal, *expression.get_next(), path) == true) return true;
      }
        }
      }
    }
  }
 
  path.pop_back();
  return false;
}

SatisfiesQueryExpression()

bool dunedaq::oks::OksObject::SatisfiesQueryExpression

(

OksQueryExpression *

query_exp

)

const

Check if object satisfies query expression.

The method parses query expression structures and applies them to the object's values. In case of incorrect query expression parameter the method throws exception.

Parameters

query_exp

the query expression

Returns

true, if object satisfies given query expression.

Exceptions

std::exception

is thrown in case of problems.

Definition at line 630 of file query.cpp.

{
  OSK_PROFILING(OksProfiler::ObjectSatisfiesQueryExpression, uid.class_id->p_kernel)
 
  if(!qe) {
    throw std::runtime_error("cannot execute nil query");
  }
 
  switch(qe->type()) {
    case OksQuery::comparator_type: {
      OksComparator *cmp = (OksComparator *)qe;
      const OksAttribute *a = cmp->attribute;
      OksQuery::Comparator f = cmp->m_comp_f;
 
      if(!a && !cmp->value) {
        throw std::runtime_error("cannot execute query for nil attribute");
      }
      else if(!f) {
        throw std::runtime_error("cannot execute query for nil compare function");
      }
 
      const OksData * cmp_value(cmp->value);
 
      if(f == OksQuery::reg_exp_cmp) { 
        if(!cmp->m_reg_exp) {
          try {
            std::string s(cmp->value->str());
            cmp->m_reg_exp = new boost::regex(s.c_str());
          }
          catch(std::exception& ex) {
            throw oks::BadReqExp(cmp->value->str(), ex.what());
          }
    }
    cmp_value = reinterpret_cast<const OksData *>(cmp->m_reg_exp);
      }
 
      if(!a) {
        OksData d(GetId());
    return (*f)(&d, cmp_value);
      }
 
      return (*f)(
        &(data[(*(uid.class_id->p_data_info->find(a->get_name()))).second->offset]),
        cmp_value
      );
    }
 
    case OksQuery::relationship_type:
      if(!((OksRelationshipExpression *)qe)->relationship) {
        throw std::runtime_error("cannot execute query for nil relationship");
      }
      else {
        OksData *d = &data[((*(uid.class_id->p_data_info->find(((OksRelationshipExpression *)qe)->relationship->get_name()))).second)->offset];
 
        if(((OksRelationshipExpression *)qe)->relationship->get_high_cardinality_constraint() == OksRelationship::Many) {
          if(!d->data.LIST || d->data.LIST->empty()) return false;
 
          for(OksData::List::iterator i = d->data.LIST->begin(); i != d->data.LIST->end(); ++i) {
            OksData *d2 = (*i);
 
            if(d2->type == OksData::uid2_type) {
              std::ostringstream text;
              text << "cannot process relationship expression: object \"" << *d2->data.UID2.object_id << '@' << *d2->data.UID2.class_id
                   << "\" referenced through multi values relationship \"" << ((OksRelationshipExpression *)qe)->relationship->get_name()
                   << "\" is not loaded in memory";
              throw std::runtime_error(text.str().c_str());
            }
 
            if(((OksRelationshipExpression *)qe)->checkAllObjects == true) {
              if(
               !d2->data.OBJECT ||
               d2->data.OBJECT->SatisfiesQueryExpression(((OksRelationshipExpression *)qe)->p_expression) == false
              ) return false;
            }
            else {
              if(
               d2->data.OBJECT &&
               d2->data.OBJECT->SatisfiesQueryExpression(((OksRelationshipExpression *)qe)->p_expression) == true
              ) return true;
            }
          }
            
          return (((OksRelationshipExpression *)qe)->checkAllObjects == true) ? true : false;
        }
        else {
          if(d->type != OksData::object_type) {
            std::ostringstream text;
            text << "cannot process relationship expression: object \"" << *d << "\" referenced through single value relationship \""
                 << ((OksRelationshipExpression *)qe)->relationship->get_name() << "\" is not loaded in memory";
            throw std::runtime_error(text.str().c_str());
          }
 
          return (
            d->data.OBJECT
          ? d->data.OBJECT->SatisfiesQueryExpression(((OksRelationshipExpression *)qe)->p_expression)
          : false
          );
        }
      }
 
    case OksQuery::not_type:
      if(!((OksNotExpression *)qe)->p_expression) {
        throw std::runtime_error("cannot process \'not\' expression: referenced query expression is nil");
      }
 
      return (SatisfiesQueryExpression(((OksNotExpression *)qe)->p_expression) ? false : true);
 
    case OksQuery::and_type:
      if(((OksAndExpression *)qe)->p_expressions.size() < 2) {
        std::ostringstream text;
        text << "cannot process \'and\' expression for " << ((OksAndExpression *)qe)->p_expressions.size()
             << " argument (two or more arguments are required)";
        throw std::runtime_error(text.str().c_str());
      }
      else {
        std::list<OksQueryExpression *> & elist = ((OksAndExpression *)qe)->p_expressions;
 
        for(std::list<OksQueryExpression *>::iterator i = elist.begin(); i != elist.end();++i)
          if(SatisfiesQueryExpression(*i) == false) return false;
 
        return true;
      }
 
    case OksQuery::or_type:
      if(((OksOrExpression *)qe)->p_expressions.size() < 2) {
        std::ostringstream text;
        text << "cannot process \'or\' expression for " << ((OksAndExpression *)qe)->p_expressions.size()
             << " argument (two or more arguments are required)";
        throw std::runtime_error(text.str().c_str());
      }
      else {
        std::list<OksQueryExpression *> & elist = ((OksOrExpression *)qe)->p_expressions;
 
        for(std::list<OksQueryExpression *>::iterator i = elist.begin(); i != elist.end();++i)
          if(SatisfiesQueryExpression(*i) == true) return true;
 
        return false;
      }
 
    default: {
      std::ostringstream text;
      text << "unexpected query type " << (int)(qe->type());
      throw std::runtime_error(text.str().c_str());
    }
  }
}

set_file()

void dunedaq::oks::OksObject::set_file	(	OksFile *	file,
		bool	update_owner = true )

Move object to different file.

Move object to an existing file. Both, present file where object is stored and new destination file have to be writable by user.

The parameters are:

Parameters

file	destination file
update_owner	mark original file as updated

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 1484 of file object.cpp.

{
  if(file != f) {
    try {
      if(update_owner) {
        file->lock();
        file->set_updated();
      }
 
      f->lock();
      f->set_updated();
 
      file = f;
    }
    catch(oks::exception& ex) {
      throw oks::CanNotSetFile(0, this, *f, ex);
    }
  }
}

set_id()

void dunedaq::oks::OksObject::set_id

(

const std::string &

id

)

Set object ID.

The ID has to be unique in scope of object's class and all classes participating in inheritance hierarchy of this class.

Parameters

id	new identity of the object In case of problems the oks::exception is thrown.

Definition at line 1506 of file object.cpp.

{
  if(new_id == uid.object_id) return;
 
  try {
    oks::validate_not_empty(new_id, "object id");
  }
  catch(std::exception& ex) {
    throw oks::FailedRenameObject(this, ex.what());
  }
 
  OksClass *c = const_cast<OksClass *>(uid.class_id);
 
  if(c->get_object(new_id)) {
    throw oks::FailedRenameObject(this, "the object with such identity already exists");
  }
 
 
    // build set of updated files and list of updated objects
 
  std::set<OksFile *> updated_files;
  std::list<OksObject *> updated_objects;
 
  updated_files.insert(file);
  updated_objects.push_back(this);
 
  const OksClass::Map & classes = GetClass()->get_kernel()->classes();
 
  for(OksClass::Map::const_iterator i = classes.begin(); i != classes.end(); ++i) {
    const OksClass * c(i->second);
    const OksObject::Map * objs = c->objects();
    size_t d_end = c->p_instance_size;
    size_t d_begin = c->p_all_attributes->size();
    if(objs && (d_end != d_begin)) {
      for(OksObject::Map::const_iterator j = objs->begin(); j != objs->end(); ++j) {
        OksObject * o(j->second);
 
          // avoid multiple notification, when renamed object contains references to self
        if(o != this) {
          for(size_t k = d_begin; k != d_end && o; ++k) {
            const OksData & d = o->data[k];
            if(d.type == OksData::object_type && d.data.OBJECT == this) {
              updated_objects.push_back(o);
              updated_files.insert(o->file);
              o = nullptr; // break loop
            }
            else if(d.type == OksData::list_type && d.data.LIST) {
              const OksData::List & list = *d.data.LIST;
              for(OksData::List::const_iterator l = list.begin(); l != list.end(); ++l) {
                OksData * d2 = *l;
                if(d2->type == OksData::object_type && d2->data.OBJECT == this) {
                  updated_objects.push_back(o);
                  updated_files.insert(o->file);
                  o = nullptr; // break loop
                  break;
                }
              }
            }
          }
        }
      }
    }
  }
 
  try {
    for(std::set<OksFile *>::const_iterator i = updated_files.begin(); i != updated_files.end(); ++i) {
      (*i)->lock();
    }
  }
  catch(oks::exception& ex) {
    throw oks::FailedRenameObject(this, ex);
  }
 
  try {
    c->remove(this);          // remove object from hash table
    uid.object_id = new_id;   // change id
    c->add(this);             // add object to hash table
  }
  catch(oks::exception& ex) {
    throw oks::FailedRenameObject(this, ex);
  }
 
  for(std::set<OksFile *>::const_iterator i = updated_files.begin(); i != updated_files.end(); ++i) {
    (*i)->set_updated();
  }
 
  if(get_change_notify()) {
    for(std::list<OksObject *>::const_iterator i = updated_objects.begin(); i != updated_objects.end(); ++i) {
      (*i)->change_notify();
    }
  }
}

set_int32_id()

void dunedaq::oks::OksObject::set_int32_id ( int32_t object_id )

inline

Set object id is used to assign an object unique integer number. Such data are not stored on file and only exist while OksKernel object is not destroyed.

Definition at line 1351 of file object.hpp.

{p_int32_id = object_id;}

set_unique_id()

void dunedaq::oks::OksObject::set_unique_id ( )

private

Definition at line 139 of file object.cpp.

{ 
  OSK_PROFILING(OksProfiler::ObjectGetFreeObjectId, uid.class_id->get_kernel())
 
  p_duplicated_object_id_idx = uid.object_id.size();
 
  std::lock_guard lock(uid.class_id->p_unique_id_mutex);
 
  std::unique_ptr<char[]> unique_id(new char[p_duplicated_object_id_idx+16]);
 
  for (unsigned long i = 0; i < 0xFFFFFFFF; ++i)
    {
      sprintf(unique_id.get(), "%s^%lu", uid.object_id.c_str(), i);
      std::string id(unique_id.get());
      if(uid.class_id->get_object(id) == nullptr)
        {
          uid.object_id = id;
          return;
        }
    }
}

SetAttributeValue() [1/2]

void dunedaq::oks::OksObject::SetAttributeValue	(	const OksDataInfo *	data_info,
		OksData *	data )

Set value of attribute by offset.

It the type of data do not match to the defined by the attribute of object's class, then the method tries to convert them and to print out warning message.

In case of problems (e.g. data are out of range) the oks::exception is thrown.

The parameters are:

Parameters

data_info	describes offset of attribute's value for given OKS class
data	new attribute value

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 1934 of file object.cpp.

{
  size_t offset = odi->offset;
  const OksAttribute * a = odi->attribute;
  OksData d2; // can be needed by type conversion
  
  if(data[offset].type != d->type) {
    if(uid.class_id->get_kernel()->get_silence_mode() == false) {
      Oks::warning_msg("OksObject::SetAttributeValue(const OksDataInfo *, OksData *)")
        << "  * ODI attribute name: \'" << a->get_name() << "\'\n"
           "  * ODI data offset: \'" << offset << "\'\n"
           "  * OKS data (new): \'" << *d << "\' type: " << (int)d->type << "\n"
           "  * OKS data (old): \'" << data[offset] << "\' type: " << (int)data[offset].type << "\n"
           "  Object " << this << ":\n"
           "  Convert attribute \"" << a->get_name() << "\" value since the OksData::type is invalid\n";
    }
 
    d->cvt(&d2, a);
    d=&d2;
  }
 
  try {
    d->check_range(a);
  }
  catch(oks::AttributeReadError & ex) {
    throw oks::ObjectSetError(this, false, a->get_name(), ex);
  }
  catch(oks::AttributeRangeError & ex) {
    throw oks::ObjectSetError(this, false, a->get_name(), ex);
  }
 
  check_file_lock(a, 0);
 
 
    // set value and update index if any
 
  {
    OksIndex * i = nullptr;
 
    if(uid.class_id->p_indices) {
      OksIndex::Map::iterator j = uid.class_id->p_indices->find(a);
      if(j != uid.class_id->p_indices->end()) {
        i = j->second;
      }
    }
 
    if(i) i->remove_obj(this);
    data[offset] = *d;
    if(i) i->insert(this);
  }
 
  notify();
}

SetAttributeValue() [2/2]

void dunedaq::oks::OksObject::SetAttributeValue	(	const std::string &	name,
		OksData *	data )

Set value of attribute by name.

It the type of data do not match to the defined by the attribute of object's class, then the method tries to convert them and to print out warning message.

In case of problems (e.g. no attribute with such name, data are out of range) the oks::exception is thrown.

The parameters are:

Parameters

name	name of attribute
data	new attribute value

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 1990 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no attribute \"" << name << '\"';
    throw oks::ObjectSetError(this, false, name, text.str());
  }
 
  SetAttributeValue(i->second, d);
}

SetRelationshipValue() [1/5]

void dunedaq::oks::OksObject::SetRelationshipValue	(	const OksDataInfo *	data_info,
		OksData *	data,
		bool	skip_non_null_check = false )

Set value of relationship by offset.

In case of problems (e.g. wrong class type or cardinality constraint) the oks::exception is thrown.

The parameters are:

Parameters

data_info	describes offset of relationship's value for given OKS class
data	new relationship value
skip_non_null_check	if true, ignore low cardinality constraint

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2055 of file object.cpp.

{
  const OksRelationship * r = odi->relationship;
  size_t offset = odi->offset;
 
  if(
   (data[offset].type != d->type) &&
   ( (d->type == OksData::list_type) || (data[offset].type == OksData::list_type) )
  ) {
    std::ostringstream text;
    text << "OKS data type is invalid: must be " << (data[offset].type == OksData::object_type ? "an object)\n" : "a list); ")
         << "offset: " << offset << "; new: \'" << *d << "\'; old:" << data[offset] << '\'';
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
    // used to update RCRs
 
  OksObject::FSet added_objs;
  OksObject::FSet removed_objs;
 
  if(d->type == OksData::object_type) {
    OksObject * add_obj = d->data.OBJECT;
    OksObject * rm_obj = (data[offset].type == OksData::object_type ? data[offset].data.OBJECT : 0);
 
    if(add_obj != rm_obj) {
      if(add_obj) added_objs.insert(add_obj);
      if(rm_obj) removed_objs.insert(rm_obj);
    }
    else {
      return; // new and old values are equal, nothing to do
    }
 
    if(skip_non_null_check == false) check_non_null(r, d->data.OBJECT);
    check_class_type(r, d->data.OBJECT);
  }
  else if(d->type == OksData::list_type && d->data.LIST) {
    if(d->data.LIST->empty()) {
      if(r->get_low_cardinality_constraint() != OksRelationship::Zero && skip_non_null_check == false) {
        throw oks::ObjectSetError(
          this, true, r->get_name(),
          "set to empty list is not allowed since the relationship has non-zero low cardinality constraint"
        );
      }
    }
 
    for(const auto& i : *d->data.LIST) {
      if(i->type != OksData::object_type && i->type != OksData::uid2_type && i->type != OksData::uid_type) {
        throw oks::ObjectSetError(this, true, r->get_name(), "list contains non-objects");
      }
 
      if(
       (i->type == OksData::object_type && !i->data.OBJECT) ||
       (i->type == OksData::uid2_type && !i->data.UID2.object_id) ||
       (i->type == OksData::uid_type && !i->data.UID.object_id)
      ) {
        throw oks::ObjectSetError(this, true, r->get_name(), "list contains (null) object");
      }
 
      if(i->type == OksData::object_type) {
        if(OksObject * o2 = i->data.OBJECT) {
          check_class_type(r, o2);
          added_objs.insert(o2);
        }
      }
    }
  }
  else {
    throw oks::ObjectSetError(
      this, true, r->get_name(),
      "the OKS data type is invalid (must be a list of objects or an object)"
    );
  }
 
  check_file_lock(0, r);
 
 
    // put old value to objects removed from relationship
 
  if(data[offset].type == OksData::list_type && data[offset].data.LIST) {
      for(const auto& i : *data[offset].data.LIST) {
        if(i->type == OksData::object_type && i->data.OBJECT) {
          removed_objs.insert(i->data.OBJECT);
        }
      }
  }
 
 
    // remove RCRs
 
  for(const auto& i : removed_objs) {
    if(added_objs.find(i) == added_objs.end()) {
      TLOG_DEBUG(4) << "object " << i << " was removed from relationship";
      i->remove_RCR(this, r);
    }
  }
 
 
    // add RCRs
 
  for(OksObject::FSet::const_iterator i = added_objs.begin(); i != added_objs.end(); ++i) {
    OksObject * add_obj = *i;
    if(removed_objs.find(add_obj) == removed_objs.end()) {
      TLOG_DEBUG(4) << "object " << add_obj << " was added to relationship";
      try {
        add_obj->add_RCR(this, r);
      }
      catch(oks::exception& ex) {
 
          // reset updated RCRs
 
        for(OksObject::FSet::const_iterator j = added_objs.begin(); j != i; ++j) {
          if(removed_objs.find(*j) == removed_objs.end()) {
            (*j)->remove_RCR(this, r);
          }
        }
 
        for(OksObject::FSet::const_iterator j = removed_objs.begin(); j != removed_objs.end(); ++j) {
          if(added_objs.find(*j) == added_objs.end()) {
            try { (*j)->add_RCR(this, r); } catch (oks::exception&) { ; }
          }
        }
 
        throw oks::ObjectSetError(this, true, r->get_name(), ex);
      }
    }
  }
 
  data[offset] = *d;
 
  notify();
}

SetRelationshipValue() [2/5]

void dunedaq::oks::OksObject::SetRelationshipValue	(	const OksDataInfo *	data_info,
		OksObject *	object )

Set value of single-value relationship by offset.

In case of problems (e.g. wrong class type or relationship is multi-value) the oks::exception is thrown.

The parameters are:

Parameters

data_info	describes offset of relationship's value for given OKS class
object	new relationship value

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2204 of file object.cpp.

{
  const OksRelationship *r = odi->relationship;
  OksData& d(data[odi->offset]);
 
  if( r->get_high_cardinality_constraint() == OksRelationship::Many ) {
    std::ostringstream text;
    text << "cannot set value " << object << " since the relationship has \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  if(!object) {
    check_non_null(r, object);
  }
  else {
    check_class_type(r, object);
  }
 
  check_file_lock(0, r);
 
  if((d.type == OksData::object_type) && d.data.OBJECT) {
    d.data.OBJECT->remove_RCR(this, r);
  }
 
  if(object) {
    try {
      object->add_RCR(this, r);
    }
    catch(oks::exception& ex) {
      // restore RCR and throw exception
      if((d.type == OksData::object_type) && d.data.OBJECT)
        try { d.data.OBJECT->add_RCR(this, r); } catch(oks::exception& ex2) { ; }
      throw oks::ObjectSetError(this, true, r->get_name(), ex);
    }
  }
 
  d.Set(object);
 
  notify();
}

SetRelationshipValue() [3/5]

void dunedaq::oks::OksObject::SetRelationshipValue	(	const std::string &	name,
		OksData *	data,
		bool	skip_non_null_check = false )

Set value of relationship by name.

In case of problems (e.g. no relationship with such name, wrong class type or cardinality constraint) the oks::exception is thrown.

The parameters are:

Parameters

name	name of relationship
data	new relationship value
skip_non_null_check	if true, ignore low cardinality constraint

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2189 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  SetRelationshipValue(i->second, d, skip_non_null_check);
}

SetRelationshipValue() [4/5]

void dunedaq::oks::OksObject::SetRelationshipValue	(	const std::string &	name,
		OksObject *	object )

Set value of single-value relationship by name.

In case of problems (e.g. no relationship with such name, wrong class type or relationship is multi-value) the oks::exception is thrown.

The parameters are:

Parameters

name	name of relationship
object	new relationship value

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2247 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
 
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  SetRelationshipValue(i->second, o);
}

SetRelationshipValue() [5/5]

void dunedaq::oks::OksObject::SetRelationshipValue	(	const std::string &	rel_name,
		const std::string &	class_name,
		const std::string &	object_id )

Set class-name and object-id value of single-value relationship by name.

In case of problems (e.g. no relationship with such name, wrong class type or relationship is multi-value) the oks::exception is thrown.

The parameters are:

Parameters

rel_name	name of relationship
class_name	class name of the referenced object
object_id	ID of the referenced object

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 2403 of file object.cpp.

{
  OksDataInfo::Map::iterator i = uid.class_id->p_data_info->find(name);
  
  if(i == uid.class_id->p_data_info->end()) {
    std::ostringstream text;
    text << "object " << this << " has no relationship \"" << name << '\"';
    throw oks::ObjectSetError(this, true, name, text.str());
  }
 
  OksDataInfo * odi = i->second;
 
 
  const OksRelationship * r = odi->relationship;
  size_t offset = odi->offset;
 
  if(object_id.empty() || class_id.empty()) {
    check_non_null(r, 0);
    check_file_lock(0, r);
 
    if( (data[offset].type == OksData::object_type) && data[offset].data.OBJECT ) {
      data[offset].data.OBJECT->remove_RCR(this, r);
    }
 
    data[offset].Set((OksObject *)0);
 
    notify();
 
    return;
  }
  
  OksClass *c = uid.class_id->p_kernel->find_class(class_id);
 
  if(c) {
    check_class_type(r, c);
  }
  else if(r->get_type() != class_id) {
    std::ostringstream text;
    text << "cannot set value \"" << object_id << '@' << class_id << "\" since the class \"" << class_id
         << "\" is not defined and it is impossible to check its validity for given type of relationship";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  if(r->get_high_cardinality_constraint() == OksRelationship::Many) {
    std::ostringstream text;
    text << "cannot set object \"" << object_id << '@' << class_id << "\" since the relationship has \'many\' high cardinality constraint";
    throw oks::ObjectSetError(this, true, r->get_name(), text.str());
  }
 
  OksObject *o = nullptr;
 
  if(c) o = c->get_object(object_id);
 
  if(o) {
    SetRelationshipValue(name, o);
  }
  else {
    check_file_lock(0, r);
 
    if( (data[offset].type == OksData::object_type) && data[offset].data.OBJECT ) {
      data[offset].data.OBJECT->remove_RCR(this, r);
    }
 
    data[offset].Set(class_id, object_id); 
 
    notify();
  }
}

SetTransientData()

void dunedaq::oks::OksObject::SetTransientData ( void * d ) const

inline

Set transient user data associated with given object. Such data are not stored on file and only exist while OksKernel object is not destroyed.

Definition at line 1335 of file object.hpp.

{p_user_data = d;}

unbind_file()

void dunedaq::oks::OksObject::unbind_file ( const OksFile * f )

private

Definition at line 2825 of file object.cpp.

{
  const size_t num_of_attrs (uid.class_id->number_of_all_attributes());
  const size_t num_of_rels  (uid.class_id->number_of_all_relationships());
 
  bool verbose = GetClass()->get_kernel()->get_verbose_mode();
 
  for(size_t i = 0; i < num_of_rels; ++i) {
    OksData *d = &data[i + num_of_attrs];
    
    if(d) {
      if(d->type == OksData::object_type) {
        OksObject * o = d->data.OBJECT;
 
        if(o && o->file == f) {
          if(verbose)
            std::cout << "- unbind_file(\'" << f->get_full_file_name() << "\') in " << this << ": replace " << *d;
 
          d->Set(o->GetClass(), o->GetId());
 
          if(verbose) std::cout << " by " << *d << std::endl;
        }
      }
      else if(d->type == OksData::list_type && d->data.LIST) {
        for(const auto& j : *d->data.LIST) {
          if(j && j->type == OksData::object_type) {
            OksObject * o = j->data.OBJECT;
 
            if(o && o->file == f) {
              if(verbose)
                std::cout << "+ unbind_file(\'" << f->get_full_file_name() << "\') in " << this << ": replace " << *j;
 
              j->Set(o->GetClass(), o->GetId());
 
              if(verbose) std::cout << " by " << *j << std::endl;
            }
          }
        }
      }
    }
  }
}

Friends And Related Symbol Documentation

oks::ReadFileParams

friend struct oks::ReadFileParams

friend

Definition at line 843 of file object.hpp.

oks::ReloadObjects

friend struct oks::ReloadObjects

friend

Definition at line 844 of file object.hpp.

OksClass

friend class OksClass

friend

Definition at line 837 of file object.hpp.

OksData

friend struct OksData

friend

Definition at line 838 of file object.hpp.

OksIndex

friend class OksIndex

friend

Definition at line 840 of file object.hpp.

OksKernel

friend class OksKernel

friend

Definition at line 839 of file object.hpp.

OksLoadObjectsJob

friend struct OksLoadObjectsJob

friend

Definition at line 842 of file object.hpp.

OksObjectSortBy

friend class OksObjectSortBy

friend

Definition at line 841 of file object.hpp.

operator<< [1/2]

std::ostream & operator<< ( std::ostream & out, const OksObject & obj )

friend

Detailed stream operator.

Send to stream complete description of OKS object:

• print class name and ID
• print value of all attributes and relationships

Definition at line 1649 of file object.cpp.

{
  OSK_PROFILING(OksProfiler::ObjectOperatorOut, o.uid.class_id->p_kernel)
  
  const OksClass * c = o.uid.class_id;
 
  s << "Object " << &o << std::endl;
  
  OksData * di = o.data;
 
 
    // print attributes
 
  {
    const std::list<OksAttribute *> * alist = c->all_attributes();
 
    if(alist && !alist->empty()) {
      s << " Attributes are:\n";
 
      for(std::list<OksAttribute *>::const_iterator i = alist->begin(); i != alist->end(); ++i) {
        if((*i)->is_integer() && (*i)->get_format() != OksAttribute::Dec) {
          s.setf(((*i)->get_format() == OksAttribute::Hex ? std::ios::hex : std::ios::oct), std::ios::basefield);
          s.setf(std::ios::showbase);
        }
 
        s << "  " << (*i)->get_name() << ": " << *di++ << std::endl;
 
        if((*i)->is_integer() && (*i)->get_format() != OksAttribute::Dec) {
          s.setf(std::ios::dec, std::ios::basefield);
          s.unsetf(std::ios::showbase);
        }
      }
    }
    else
      s << " There are no attributes\n";
  }
 
 
    // print relationships
 
  {
    const std::list<OksRelationship *> * rlist = c->all_relationships();
 
    if(rlist && !rlist->empty()) {
      s << " Relationships are:\n";
        
      for(std::list<OksRelationship *>::const_iterator i = rlist->begin(); i != rlist->end(); ++i)
        s << "  " << (*i)->get_name() << ": " << *di++ << std::endl;
    }
    else
      s << " There are no relationships\n";
  }
 
  return s;
}   

operator<< [2/2]

std::ostream & operator<< ( std::ostream & s, const OksObject * o )

friend

Short stream operator.

Send to stream OKS object reference in format "foo@bar" (i.e. object "foo" from class "bar")

Definition at line 1633 of file object.cpp.

{
  s << '\"';
  
  if(o)
    s << o->GetId() << '@' << o->GetClass()->get_name();
  else
    s << "(null-obj)";
 
  s << '\"';
  
  return s;
}

Member Data Documentation

attribute_xml_tag

const char dunedaq::oks::OksObject::attribute_xml_tag = "attr"

staticprivate

Definition at line 1515 of file object.hpp.

class2_xml_attribute

const char dunedaq::oks::OksObject::class2_xml_attribute = "c"

staticprivate

Definition at line 1518 of file object.hpp.

class_xml_attribute

const char dunedaq::oks::OksObject::class_xml_attribute = "class"

staticprivate

Definition at line 1517 of file object.hpp.

data

OksData* dunedaq::oks::OksObject::data

private

Definition at line 1405 of file object.hpp.

data_xml_tag

const char dunedaq::oks::OksObject::data_xml_tag = "data"

staticprivate

Definition at line 1526 of file object.hpp.

file

OksFile* dunedaq::oks::OksObject::file

private

Definition at line 1410 of file object.hpp.

id2_xml_attribute

const char dunedaq::oks::OksObject::id2_xml_attribute = "i"

staticprivate

Definition at line 1520 of file object.hpp.

id_xml_attribute

const char dunedaq::oks::OksObject::id_xml_attribute = "id"

staticprivate

Definition at line 1519 of file object.hpp.

name_xml_attribute

const char dunedaq::oks::OksObject::name_xml_attribute = "name"

staticprivate

Definition at line 1521 of file object.hpp.

num_xml_attribute

const char dunedaq::oks::OksObject::num_xml_attribute = "num"

staticprivate

Definition at line 1523 of file object.hpp.

obj2_xml_tag

const char dunedaq::oks::OksObject::obj2_xml_tag = "o"

staticprivate

Definition at line 1514 of file object.hpp.

obj_xml_tag

const char dunedaq::oks::OksObject::obj_xml_tag = "obj"

staticprivate

Definition at line 1513 of file object.hpp.

p_duplicated_object_id_idx

int32_t dunedaq::oks::OksObject::p_duplicated_object_id_idx

private

Definition at line 1409 of file object.hpp.

p_int32_id

int32_t dunedaq::oks::OksObject::p_int32_id

private

Definition at line 1408 of file object.hpp.

p_rcr

std::list<OksRCR *>* dunedaq::oks::OksObject::p_rcr

private

Definition at line 1406 of file object.hpp.

p_user_data

void* dunedaq::oks::OksObject::p_user_data

mutableprivate

Definition at line 1407 of file object.hpp.

ref_xml_tag

const char dunedaq::oks::OksObject::ref_xml_tag = "ref"

staticprivate

Definition at line 1527 of file object.hpp.

relationship_xml_tag

const char dunedaq::oks::OksObject::relationship_xml_tag = "rel"

staticprivate

Definition at line 1516 of file object.hpp.

type_xml_attribute

const char dunedaq::oks::OksObject::type_xml_attribute = "type"

staticprivate

Definition at line 1522 of file object.hpp.

uid

struct dunedaq::oks::OksObject::OksUid dunedaq::oks::OksObject::uid

private

value_xml_attribute

const char dunedaq::oks::OksObject::value_xml_attribute = "val"

staticprivate

Definition at line 1525 of file object.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/oks/include/oks/object.hpp
• /github/workspace/dunedaq/sourcecode/oks/src/object.cpp
• /github/workspace/dunedaq/sourcecode/oks/src/query.cpp