object.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: no.
 
#define _OksBuildDll_
 
#include "oks/object.hpp"
#include "oks/attribute.hpp"
#include "oks/class.hpp"
#include "oks/cstring.hpp"
#include "oks/index.hpp"
#include "oks/kernel.hpp"
#include "oks/profiler.hpp"
#include "oks/relationship.hpp"
#include "oks/xml.hpp"
 
#include "oks_utils.hpp"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <iostream>
#include <sstream>
#include <stdexcept>
 
#include "ers/ers.hpp"
#include "logging/Logging.hpp"
 
namespace dunedaq {
namespace oks {
 
// names of xml tags and attributes (differed for compact and extended files)
 
const char OksObject::obj_xml_tag[] = "obj";
const char OksObject::obj2_xml_tag[] = "o";
const char OksObject::class_xml_attribute[] = "class";
const char OksObject::class2_xml_attribute[] = "c";
const char OksObject::id_xml_attribute[] = "id";
const char OksObject::id2_xml_attribute[] = "i";
 
// names of xml tags and attributes (update oks::cmp_strN calls, if touch below lines)
 
const char OksObject::attribute_xml_tag[] = "attr";
const char OksObject::relationship_xml_tag[] = "rel";
const char OksObject::name_xml_attribute[] = "name";
const char OksObject::type_xml_attribute[] = "type";
const char OksObject::num_xml_attribute[] = "num";
const char OksObject::value_xml_attribute[] = "val";
 
const char OksObject::data_xml_tag[] = "data";
const char OksObject::ref_xml_tag[] = "ref";
 
std::string
FailedReadObject::fill(const OksObject* o, const std::string& what, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to read \'" << what << "\' of object " << o << '\n' << reason;
  return s.str();
}
 
std::string
FailedCreateObject::fill(const OksObject* o, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to create object " << o << '\n' << reason;
  return s.str();
}
 
std::string
FailedSaveObject::fill(const OksObject* o, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to save object " << o << '\n' << reason;
  return s.str();
}
 
std::string
FailedRenameObject::fill(const OksObject* o, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to rename object " << o << '\n' << reason;
  return s.str();
}
 
std::string
FailedDestoyObject::fill(const OksObject* o, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to destroy object " << o << '\n' << reason;
  return s.str();
}
 
std::string
ObjectSetError::fill(const OksObject* obj, bool is_rel, const std::string& name, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to set " << (is_rel ? "relationship" : "attribute") << " \'" << name << "\' of object " << obj << '\n'
    << reason;
  return s.str();
}
 
std::string
ObjectGetError::fill(const OksObject* obj, bool is_rel, const std::string& name, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to get " << (is_rel ? "relationship" : "attribute") << " \'" << name << "\' of object " << obj << '\n'
    << reason;
  return s.str();
}
 
std::string
AddRcrError::fill(const OksObject* obj, const std::string& name, const OksObject* p1, const OksObject* p2)
{
  std::ostringstream s;
  s << "Object " << obj << " cannot be linked with " << p1 << " via exclusive relationship \'" << name
    << "\' since it is already referenced by object " << p2;
  return s.str();
}
 
std::string
ObjectInitError::fill(const OksObject* obj, const std::string& why, const std::string& reason)
{
  std::ostringstream s;
  s << "Failed to init object " << obj << " because " << why << '\n' << reason;
  return s.str();
}
 
std::string
ObjectBindError::fill(const OksObject* obj,
                      const OksRelationship* rel,
                      const std::string& why,
                      const std::string& reason)
{
  p_rel = rel;
  std::ostringstream s;
  s << "Failed to bind relationship";
  if (p_rel) {
    s << " \"" << p_rel->get_name() << '\"';
  } else {
    s << 's';
  }
  s << " of object " << obj << " because:\n" << why;
  if (!reason.empty())
    s << '\n' << reason;
  return s.str();
}
 
void
OksObject::set_unique_id()
{
  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;
    }
  }
}
 
void
OksObject::check_ids()
{
  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());
      }
    }
  }
}
 
void
OksObject::init1(const OksFile* fp)
{
  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();
}
 
void
OksData::set_init_value(const OksAttribute* a, bool skip_init)
{
  bool si = (a->get_init_value().empty() || skip_init);
 
  if (a->get_is_multi_values() == false) {
    type = a->get_data_type();
    if (si) {
      SetNullValue(a);
    } else {
      if (type == OksData::string_type) {
        data.STRING = new OksString(a->get_init_value());
      } else if (type == OksData::enum_type) {
        data.ENUMERATION = a->get_enum_value(a->get_init_value());
      } else {
        SetValue(a->get_init_value().c_str(), a);
      }
    }
  } else {
    if (si) {
      SetValues("", a);
    } else {
      SetValues(a->get_init_value().c_str(), a);
    }
  }
}
 
void
OksObject::init2(bool skip_init)
{
  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();
      }
    }
  }
}
 
void
OksObject::init3(OksClass* c)
{
  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);
}
 
void
OksObject::init3()
{
  init3(const_cast<OksClass*>(uid.class_id));
  create_notify();
}
 
#define READ_OBJ_HEADER(F1, S1, F2, S2)                                                                                \
  while (true) {                                                                                                       \
    OksXmlAttribute attr(read_params.s);                                                                               \
    if (oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) {                                          \
      break;                                                                                                           \
    } else if (F1(attr.name(), S1)) {                                                                                  \
      std::shared_lock lock(read_params.oks_kernel->p_schema_mutex);                                                   \
      c = read_params.oks_kernel->find_class(attr.value());                                                            \
      if (__builtin_expect((c == nullptr), 0)) {                                                                       \
        std::ostringstream text;                                                                                       \
        text << "cannot find class \"" << attr.value() << "\" (line " << read_params.s.get_line_no() << ", char "      \
             << read_params.s.get_line_pos() << ')';                                                                   \
        throw std::runtime_error(text.str().c_str());                                                                  \
      }                                                                                                                \
    } else if (F2(attr.name(), S2))                                                                                    \
      id.assign(attr.value(), attr.value_len());                                                                       \
    else {                                                                                                             \
      read_params.s.throw_unexpected_attribute(attr.name());                                                           \
    }                                                                                                                  \
  }
 
void
oks::ReadFileParams::init()
{
  if (format != 'c') {
    object_tag = OksObject::obj_xml_tag;
    object_tag_len = sizeof(OksObject::obj_xml_tag);
  } else {
    object_tag = OksObject::obj2_xml_tag;
    object_tag_len = sizeof(OksObject::obj2_xml_tag);
  }
}
 
OksObject*
OksObject::read(const oks::ReadFileParams& read_params)
{
  // 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;
}
 
void
OksObject::__report_type_cvt_warning(const oks::ReadFileParams& params,
                                     const OksAttribute& a,
                                     const OksData& d,
                                     OksData::Type type,
                                     int32_t num) const
{
  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;
}
 
void
OksObject::__report_cardinality_cvt_warning(const oks::ReadFileParams& params, const OksRelationship& r) const
{
  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;
}
 
static void
__throw_unknown_type(const oks::ReadFileParams& params, const char* atype)
{
  std::ostringstream s;
  s << "Unknown attribute type \"" << atype << '\"';
  throw oks::BadFileData(s.str(), params.s.get_line_no(), params.s.get_line_pos());
}
 
int32_t
OksObject::__get_num(const oks::ReadFileParams& params)
{
  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;
}
 
void
OksObject::read_body(const oks::ReadFileParams& read_params, bool re_read)
{
  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();
}
 
OksObject::OksObject(const oks::ReadFileParams& read_params, OksClass* c, const std::string& id)
  : 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::OksObject(const OksClass* c, const char* object_id, bool skip_init)
  : 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::OksObject(const OksObject& parentObj, const char* object_id)
  : 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::OksObject(size_t offset, const OksData* d)
  : 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::OksObject(OksClass* c,
                     const std::string& id,
                     void* user_data,
                     int32_t int32_id,
                     int32_t duplicated_object_id_idx,
                     OksFile* f)
  : 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);
  }
}
 
void
OksObject::destroy(OksObject* o, bool fast)
{
  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;
}
 
OksObject::~OksObject()
{
  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);
    }
  }
}
 
void
OksObject::set_file(OksFile* f, bool update_owner)
{
  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);
    }
  }
}
 
void
OksObject::set_id(const std::string& new_id)
{
  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();
    }
  }
}
 
bool
OksObject::are_equal_fast(const OksObject* o1, const OksObject* o2)
{
  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);
}
 
bool
OksObject::operator==(const OksObject& o) const
{
  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;
}
 
std::ostream&
operator<<(std::ostream& s, const OksObject* o)
{
  s << '\"';
 
  if (o)
    s << o->GetId() << '@' << o->GetClass()->get_name();
  else
    s << "(null-obj)";
 
  s << '\"';
 
  return s;
}
 
std::ostream&
operator<<(std::ostream& s, const OksObject& o)
{
  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;
}
 
//
// Remove dangling objects before writing to file
// Avoid unnecessary additional checks
//
 
static bool
trim_dangling(OksData& d, const OksKernel& kernel)
{
  if (d.type == OksData::object_type) {
    if (d.data.OBJECT && kernel.is_dangling(d.data.OBJECT)) {
      d.data.OBJECT = nullptr;
    }
 
    return (d.data.OBJECT != nullptr);
  } else if (d.type == OksData::list_type) {
    if (d.data.LIST) {
      for (OksData::List::iterator i = d.data.LIST->begin(); i != d.data.LIST->end();) {
        OksData* d2 = *i;
        if (d2->type == OksData::object_type) {
          if (d2->data.OBJECT == nullptr || kernel.is_dangling(d2->data.OBJECT)) {
            i = d.data.LIST->erase(i);
            delete d2;
            continue;
          }
        }
        ++i;
      }
 
      return (!d.data.LIST->empty());
    } else
      return false;
  }
 
  return true;
}
 
void
OksObject::put_object_attributes(OksXmlOutputStream& xmls, const OksData& d)
{
  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());
}
 
void
OksObject::put(OksXmlOutputStream& xmls, bool force_defaults) const
{
  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"));
  }
}
 
OksData*
OksObject::GetAttributeValue(const std::string& name) const
{
  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);
}
 
void
OksObject::SetAttributeValue(const OksDataInfo* odi, OksData* d)
{
  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();
}
 
void
OksObject::SetAttributeValue(const std::string& name, OksData* d)
{
  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);
}
 
OksData*
OksObject::GetRelationshipValue(const std::string& name) const
{
  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);
}
 
void
OksObject::check_non_null(const OksRelationship* r, const OksObject* o)
{
  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");
  }
}
 
void
OksObject::check_class_type(const OksRelationship* r, const OksClass* class_type)
{
  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());
  }
}
 
void
OksObject::SetRelationshipValue(const OksDataInfo* odi, OksData* d, bool skip_non_null_check)
{
  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();
}
 
void
OksObject::SetRelationshipValue(const std::string& name, OksData* d, bool skip_non_null_check)
{
  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);
}
 
void
OksObject::SetRelationshipValue(const OksDataInfo* odi, OksObject* object)
{
  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();
}
 
void
OksObject::SetRelationshipValue(const std::string& name, OksObject* o)
{
  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);
}
 
static bool
cmp_data(OksData* d, OksData* d2)
{
  if (d->type == OksData::object_type && d2->type == OksData::object_type)
    return ((d2->data.OBJECT == d->data.OBJECT) ? true : false);
 
  const std::string& object_id = d->type == OksData::object_type ? d->data.OBJECT->GetId()
                                 : d->type == OksData::uid2_type ? *(static_cast<std::string*>(d->data.UID2.object_id))
                                                                 : *(static_cast<std::string*>(d->data.UID.object_id));
 
  const std::string& object_id2 = d2->type == OksData::object_type ? d2->data.OBJECT->GetId()
                                  : d2->type == OksData::uid2_type
                                    ? *(static_cast<std::string*>(d2->data.UID2.object_id))
                                    : *(static_cast<std::string*>(d2->data.UID.object_id));
 
  if (object_id != object_id2)
    return false;
 
  const OksClass* pclass_id = d->type == OksData::object_type ? d->data.OBJECT->GetClass()
                              : d->type == OksData::uid_type  ? d->data.UID.class_id
                                                              : 0;
 
  const OksClass* pclass_id2 = d2->type == OksData::object_type ? d2->data.OBJECT->GetClass()
                               : d2->type == OksData::uid_type  ? d2->data.UID.class_id
                                                                : 0;
 
  if (pclass_id && pclass_id2)
    return (pclass_id == pclass_id2 ? true : false);
 
  const std::string& class_id =
    (pclass_id ? pclass_id->get_name() : *(static_cast<std::string*>(d->data.UID2.class_id)));
 
  const std::string& class_id2 =
    (pclass_id2 ? pclass_id2->get_name() : *(static_cast<std::string*>(d2->data.UID2.class_id)));
 
  return (class_id == class_id2 ? true : false);
}
 
void
OksObject::AddRelationshipValue(const OksDataInfo* odi, OksObject* object)
{
  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();
}
 
void
OksObject::AddRelationshipValue(const std::string& name, OksObject* object)
{
  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);
}
 
void
OksObject::RemoveRelationshipValue(const OksDataInfo* odi, OksObject* object)
{
  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());
}
 
void
OksObject::RemoveRelationshipValue(const std::string& name, OksObject* object)
{
  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);
}
 
void
OksObject::SetRelationshipValue(const std::string& name, const std::string& class_id, const std::string& object_id)
{
  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();
  }
}
 
void
OksObject::AddRelationshipValue(const std::string& name, const std::string& class_id, const std::string& object_id)
{
  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();
  }
}
 
void
OksObject::RemoveRelationshipValue(const std::string& name, const std::string& class_id, const std::string& object_id)
{
  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());
}
 
void
OksObject::add_RCR(OksObject* o, const OksRelationship* r)
{
  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));
}
 
void
OksObject::remove_RCR(OksObject* o, const OksRelationship* r) noexcept
{
  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;
  }
}
 
void
OksObject::bind(OksData* d, const BindInfo& info)
{
  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);
  }
}
 
struct BindWarning
{
  std::ostringstream* p_warnings; // in 99.999% cases there is no need to call the constructor
  unsigned int p_warnings_count;
 
  BindWarning()
    : p_warnings(0)
    , p_warnings_count(0)
  {
    ;
  }
  ~BindWarning() { delete p_warnings; }
 
  void add(const OksData& d, const OksRelationship* r);
  void add(const OksRelationship* r);
  std::ostringstream& add();
};
 
std::ostringstream&
BindWarning::add()
{
  if (p_warnings_count != 0)
    (*p_warnings) << '\n';
  else {
    p_warnings = new std::ostringstream();
  }
  p_warnings_count++;
  return *p_warnings;
}
 
void
BindWarning::add(const OksData& d, const OksRelationship* r)
{
  add() << " * object " << d << " via relationship \"" << r->get_name() << '\"';
}
 
void
BindWarning::add(const OksRelationship* r)
{
  add() << " * relationship \"" << r->get_name() << "\" has non-zero low cardinality constraint, but it is empty";
}
 
void
OksObject::bind_objects()
{
  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(), "");
  }
}
 
void
OksObject::unbind_file(const OksFile* f)
{
  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;
            }
          }
        }
      }
    }
  }
}
 
OksObject::notify_obj
OksObject::get_change_notify() const
{
  return uid.class_id->p_kernel->p_change_object_notify_fn;
}

 
void
OksObject::create_notify()
{
  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);
  }
}

 
void
OksObject::change_notify()
{
  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);
  }
}

 
void
OksObject::delete_notify()
{
  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);
  }
}
 
bool
OksObject::check_links_and_report(const OksObject* o2,
                                  const std::set<OksFile*>& includes,
                                  const std::string& name,
                                  const char* msg) const
{
  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;
}
 
static void
test_dangling_references(const OksObject* obj, const OksData& d, const OksRelationship& r, std::string& result)
{
  if (d.type == OksData::uid_type || d.type == OksData::uid2_type) {
    std::ostringstream text;
 
    if (result.empty()) {
      text << " * object " << obj << " has dangling references:\n";
    }
 
    text << "  - object " << d << " referenced via \'" << r.get_name() << "\'\n";
 
    result += text.str();
  }
}
 
std::string
OksObject::report_dangling_references() const
{
  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;
}
 
bool
OksObject::is_consistent(const std::set<OksFile*>& includes, const char* msg) const
{
  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;
}
 
struct RefData
{
  OksObject::FSet& refs;
  OksObject::FSet tested_objs;
  oks::ClassSet* classes;
 
  RefData(OksObject::FSet& r, oks::ClassSet* cs)
    : refs(r)
    , classes(cs)
  {
    if (classes && classes->empty())
      classes = nullptr;
  }
};
 
static void
_references(const OksObject* obj, unsigned long recursion_depth, RefData& data);
 
static void
insert2refs(const OksObject* o, unsigned long recursion_depth, RefData& data)
{
  recursion_depth--;
 
  std::pair<OksObject::FSet::iterator, bool> ret = data.tested_objs.insert(const_cast<OksObject*>(o));
 
  if (ret.second == true) {
    if (data.classes == nullptr || data.classes->find(const_cast<OksClass*>(o->GetClass())) != data.classes->end()) {
      data.refs.insert(const_cast<OksObject*>(o));
    }
    o->SetTransientData((void*)recursion_depth);
    _references(o, recursion_depth, data);
  } else if (o->GetTransientData() < (void*)recursion_depth) {
    o->SetTransientData((void*)recursion_depth);
    _references(o, recursion_depth, data);
  }
}
 
static void
_references(const OksObject* obj, unsigned long recursion_depth, RefData& data)
{
  if (recursion_depth == 0)
    return;
 
  size_t l1 = obj->GetClass()->number_of_all_attributes();
  size_t l2 = l1 + obj->GetClass()->number_of_all_relationships();
 
  while (l1 < l2) {
    OksDataInfo odi(l1, (OksRelationship*)0);
    OksData* d(obj->GetRelationshipValue(&odi));
 
    if (d->type == OksData::object_type) {
      if (OksObject* o2 = d->data.OBJECT) {
        insert2refs(o2, recursion_depth, data);
      }
    } 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) {
            insert2refs(o2, recursion_depth, data);
          }
        }
      }
    }
 
    ++l1;
  }
}
 
void
OksObject::references(OksObject::FSet& refs, unsigned long recursion_depth, bool add_self, oks::ClassSet* classes) const
{
  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";
}
 
OksObject::FList*
OksObject::get_all_rels(const std::string& name) const
{
  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;
}
 
void
OksObject::check_file_lock(const OksAttribute* a, const OksRelationship* r)
{
  try {
    file->lock();
  } catch (oks::exception& ex) {
    throw oks::ObjectSetError(this, (a == nullptr), (a ? a->get_name() : r->get_name()), ex);
  }
}
 
} // namespace oks
} // namespace dunedaq