class.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/class.hpp"
#include "oks/cstring.hpp"
#include "oks/index.hpp"
#include "oks/kernel.hpp"
#include "oks/method.hpp"
#include "oks/object.hpp"
#include "oks/profiler.hpp"
#include "oks/relationship.hpp"
#include "oks/xml.hpp"
 
#include "ers/ers.hpp"
#include "logging/Logging.hpp"
 
#include <stdlib.h>
 
#include <algorithm>
#include <stdexcept>
#include <string>
 
namespace dunedaq {
namespace oks {
 
const char OksClass::class_xml_tag[] = "class";
const char OksClass::name_xml_attr[] = "name";
const char OksClass::description_xml_attr[] = "description";
const char OksClass::is_abstract_xml_attr[] = "is-abstract";
const char OksClass::superclass_xml_attr[] = "superclass";
 
OksClass::NotifyFN OksClass::create_notify_fn;
OksClass::ChangeNotifyFN OksClass::change_notify_fn;
OksClass::NotifyFN OksClass::delete_notify_fn;
 
std::string
CannotFindSuperClass::fill(const OksClass& c, const std::string& name) noexcept
{
  return std::string("cannot find superclass \'") + name + "\' of class \'" + c.get_name() + '\'';
}
 
std::string
AttributeConversionFailed::fill(const OksAttribute& a, const OksObject* o, const std::string& reason) noexcept
{
  std::ostringstream s;
  s << "failed to convert \'" << a.get_name() << "\" value of object " << o << " because:\n" + reason;
  return s.str();
}
 
std::string
CannotRegisterClass::fill(const OksClass& c, const std::string& what, const std::string& reason) noexcept
{
  return std::string("cannot register class \'") + c.get_name() + "\' " + what + "because:\n" + reason;
}
 
std::string
CannotDestroyClass::fill(const OksClass& c, const std::string& reason) noexcept
{
  return std::string("cannot destroy class \'") + c.get_name() + "\' because:\n" + reason;
}
 
std::string
ObjectOperationFailed::fill(const OksClass& c,
                            const std::string& oid,
                            const char* op,
                            const std::string& reason) noexcept
{
  return std::string("cannot ") + op + " object \'" + oid + "\' in class \'" + c.get_name() + "\' because:\n" + reason;
}
 
std::string
SetOperationFailed::fill(const char* op, const std::string& reason) noexcept
{
  return std::string("method \'") + op + "()\' failed because:\n" + reason;
}
 
OksClass::OksClass(const std::string& nm, OksKernel* k, bool t)
  : p_name(nm)
  , p_super_classes(0)
  , p_attributes(0)
  , p_relationships(0)
  , p_methods(0)
  , p_abstract(false)
  , p_transient(t)
  , p_to_be_deleted(false)
  , p_all_super_classes(0)
  , p_all_sub_classes(0)
  , p_all_attributes(0)
  , p_all_relationships(0)
  , p_all_methods(0)
  , p_inheritance_hierarchy(0)
  , p_kernel(k)
  , p_instance_size(0)
  , p_data_info(0)
  , p_objects(0)
  , p_indices(0)
{
  OSK_PROFILING(OksProfiler::ClassConstructor, p_kernel)
 
  if (p_transient == false && p_kernel) {
    oks::validate_not_empty(p_name, "class name");
 
    std::unique_lock lock(p_kernel->p_kernel_mutex);
    p_kernel->k_add(this);
  }
}
 
OksClass::OksClass(const std::string& nm, const std::string& d, bool a, OksKernel* k, bool t)
  : p_name(nm)
  , p_description(d)
  , p_super_classes(0)
  , p_attributes(0)
  , p_relationships(0)
  , p_methods(0)
  , p_abstract(a)
  , p_transient(t)
  , p_to_be_deleted(false)
  , p_all_super_classes(0)
  , p_all_sub_classes(0)
  , p_all_attributes(0)
  , p_all_relationships(0)
  , p_all_methods(0)
  , p_inheritance_hierarchy(0)
  , p_kernel(k)
  , p_instance_size(0)
  , p_data_info(0)
  , p_objects(0)
  , p_indices(0)
{
  OSK_PROFILING(OksProfiler::ClassConstructor, p_kernel)
 
  if (p_transient == false && p_kernel) {
    oks::validate_not_empty(p_name, "class name");
 
    std::unique_lock lock(p_kernel->p_kernel_mutex);
    p_kernel->k_add(this);
  }
}
 
OksClass::OksClass(OksKernel* kernel, const std::string& name, const std::string& description, bool is_abstract)
  : p_name(name)
  , p_description(description)
  , p_super_classes(0)
  , p_attributes(0)
  , p_relationships(0)
  , p_methods(0)
  , p_abstract(is_abstract)
  , p_transient(false)
  , p_to_be_deleted(false)
  , p_all_super_classes(0)
  , p_all_sub_classes(0)
  , p_all_attributes(0)
  , p_all_relationships(0)
  , p_all_methods(0)
  , p_inheritance_hierarchy(0)
  , p_file(kernel->p_active_schema)
  , p_kernel(kernel)
  , p_instance_size(0)
  , p_data_info(0)
  , p_objects(0)
  , p_indices(0)
{
  OSK_PROFILING(OksProfiler::ClassConstructor, p_kernel)
  p_kernel->p_classes[p_name.c_str()] = this;
}
 
void
OksClass::destroy(OksClass* c)
{
  // obtain write mutex, if non-transient class is registered in the oks kernel
 
  if (!c->p_transient && c->p_kernel) {
    std::unique_lock lock(c->p_kernel->p_kernel_mutex);
 
    try {
      c->p_file->lock();
      c->p_file->set_updated();
    } catch (oks::exception& ex) {
      throw oks::CannotDestroyClass(*c, ex);
    }
 
    delete c;
  }
 
  // destroy class without get write mutex
 
  else {
    delete c;
  }
}
 
template<class T>
void
OksClass::destroy_list(T list)
{
  if (list) {
    for (const auto& x : *list)
      delete x;
 
    delete list;
  }
}
 
template<class T>
void
OksClass::destroy_map(T map)
{
  if (map) {
    for (const auto& x : *map)
      delete x.second;
 
    delete map;
  }
}
 
OksClass::~OksClass()
{
  OSK_PROFILING(OksProfiler::ClassDestructor, p_kernel)
 
  TLOG_DEBUG(2) << "destruct " << (p_transient ? "TRANSIENT" : "NORMAL") << " class \'" << get_name() << '\'';
 
  // ~OksIndex() removes 'SELF' from OksClass and deletes 'indices' when there is no an index in it
  while (p_indices)
    delete (*(p_indices->begin())).second;
 
  destroy_map(p_objects);
  destroy_map(p_data_info);
 
  if (!p_transient && p_kernel) {
    p_kernel->k_remove(this);
 
    if (p_all_super_classes)
      for (const auto& c : *p_all_super_classes) {
        if (p_kernel->is_dangling(c) || c->p_to_be_deleted)
          continue;
 
        c->create_sub_classes();
 
        if (OksClass::change_notify_fn)
          (*OksClass::change_notify_fn)(c, ChangeSubClassesList, (const void*)&p_name);
      }
 
    if (p_all_sub_classes)
      for (const auto& c : *p_all_sub_classes) {
        if (p_kernel->is_dangling(c) || c->p_to_be_deleted)
          continue;
 
        try {
          c->registrate_class_change(ChangeSuperClassesList, (const void*)&p_name, false);
        } catch (oks::exception& ex) {
          std::cerr << "internal OKS error: registrate_class_change() failed during \'" << get_name()
                    << "\' class destruction\ncaused by: " << ex.what() << std::endl;
        }
      }
  }
 
  destroy_list(p_super_classes);
  destroy_list(p_attributes);
  destroy_list(p_relationships);
  destroy_list(p_methods);
 
  if (!p_transient) {
    delete p_all_super_classes;
    delete p_all_sub_classes;
    delete p_all_attributes;
    delete p_all_relationships;
    delete p_all_methods;
    delete p_inheritance_hierarchy;
  }
}
 
void
OksClass::set_file(OksFile* f, bool update_owner)
{
  if (p_file != f) {
    try {
      if (update_owner) {
        p_file->lock();
        p_file->set_updated();
      }
 
      f->lock();
      f->set_updated();
 
      p_file = f;
    } catch (oks::exception& ex) {
      throw oks::CanNotSetFile(this, 0, *f, ex);
    }
  }
}
 
bool
OksClass::compare_without_methods(const OksClass& c) const noexcept
{
  if (this == &c)
    return true;
 
  if ((p_name != c.p_name) || (p_description != c.p_description) || (p_abstract != c.p_abstract))
    return false;
 
  int l1 = (p_attributes == 0) ? 0 : p_attributes->size();
  int l2 = (c.p_attributes == 0) ? 0 : c.p_attributes->size();
 
  if (l1 != l2)
    return false;
 
  if (l1 > 0) {
    std::list<OksAttribute*>::const_iterator i1 = p_attributes->begin();
    std::list<OksAttribute*>::const_iterator i2 = c.p_attributes->begin();
 
    for (; i1 != p_attributes->end(); ++i1, ++i2)
      if (!(*(*i1) == *(*i2)))
        return false;
  }
 
  l1 = (p_relationships == 0) ? 0 : p_relationships->size();
  l2 = (c.p_relationships == 0) ? 0 : c.p_relationships->size();
 
  if (l1 != l2)
    return false;
 
  if (l1 > 0) {
    std::list<OksRelationship*>::const_iterator i1 = p_relationships->begin();
    std::list<OksRelationship*>::const_iterator i2 = c.p_relationships->begin();
 
    for (; i1 != p_relationships->end(); ++i1, ++i2)
      if (!(*(*i1) == *(*i2)))
        return false;
  }
 
  l1 = (p_super_classes == 0) ? 0 : p_super_classes->size();
  l2 = (c.p_super_classes == 0) ? 0 : c.p_super_classes->size();
 
  if (l1 != l2)
    return false;
 
  if (l1 > 0) {
    std::list<std::string*>::const_iterator i1 = p_super_classes->begin();
    std::list<std::string*>::const_iterator i2 = c.p_super_classes->begin();
 
    for (; i1 != p_super_classes->end(); ++i1, ++i2)
      if (!(*(*i1) == *(*i2)))
        return false;
  }
 
  return true;
}
 
bool
OksClass::operator!=(const OksClass& c) const
{
  if (this == &c)
    return false;
 
  if (compare_without_methods(c) == false)
    return true;
 
  int l1 = (p_methods == 0) ? 0 : p_methods->size();
  int l2 = (c.p_methods == 0) ? 0 : c.p_methods->size();
 
  if (l1 != l2)
    return true;
 
  if (l1 > 0) {
    std::list<OksMethod*>::const_iterator i1 = p_methods->begin();
    std::list<OksMethod*>::const_iterator i2 = c.p_methods->begin();
 
    for (; i1 != p_methods->end(); ++i1, ++i2)
      if (!(*(*i1) == *(*i2)))
        return true;
  }
 
  return false;
}
 
std::ostream&
operator<<(std::ostream& s, const OksClass& c)
{
  OSK_PROFILING(OksProfiler::ClassOperatorOut, c.p_kernel)
 
  s << "Class name: \"" << c.p_name
    << "\"\n"
       " has description: \""
    << c.p_description << "\"\n"
    << (c.p_abstract == true ? " is abstract\n" : " is not abstract\n");
 
  if (c.p_super_classes) {
    s << "The class has superclasses:\n";
    for (std::list<std::string*>::const_iterator i = c.p_super_classes->begin(); i != c.p_super_classes->end(); ++i) {
      s << " - " << *(*i) << std::endl;
    }
  } else
    s << "The class has no superclasses\n";
 
  if (c.p_attributes) {
    s << "The attributes are:\n";
    for (std::list<OksAttribute*>::const_iterator i = c.p_attributes->begin(); i != c.p_attributes->end(); ++i) {
      s << *(*i);
    }
  } else
    s << "There are no attributes\n";
 
  if (c.p_relationships) {
    s << "The relationships are:\n";
    for (std::list<OksRelationship*>::const_iterator i = c.p_relationships->begin(); i != c.p_relationships->end();
         ++i) {
      s << *(*i);
    }
  } else
    s << "There are no relationships\n";
 
  if (c.p_methods) {
    s << "The methods are:\n";
    for (std::list<OksMethod*>::const_iterator i = c.p_methods->begin(); i != c.p_methods->end(); ++i) {
      s << *(*i);
    }
  } else
    s << "There are no methods\n";
 
  if (c.p_objects) {
    OksObject::SMap sorted;
 
    s << "The objects are:\n";
 
    for (OksObject::Map::iterator i = c.p_objects->begin(); i != c.p_objects->end(); ++i) {
      sorted[i->first] = i->second;
    }
 
    for (OksObject::SMap::iterator i = sorted.begin(); i != sorted.end(); ++i) {
      s << *(i->second);
    }
  } else
    s << "There are no objects\n";
 
  s << "End of Class \"" << c.p_name << "\"\n";
 
  return s;
}
 
void
OksClass::save(OksXmlOutputStream& s) const
{
  try {
    s.put_raw(' ');
    s.put_start_tag(class_xml_tag, sizeof(class_xml_tag) - 1);
    s.put_attribute(name_xml_attr, sizeof(name_xml_attr) - 1, p_name.c_str());
 
    // store non-empty description only
    if (!p_description.empty())
      s.put_attribute(description_xml_attr, sizeof(description_xml_attr) - 1, p_description.c_str());
 
    // store abstract attribute only when the class is abstract
    if (p_abstract)
      s.put_attribute(is_abstract_xml_attr, sizeof(is_abstract_xml_attr) - 1, oks::xml::bool2str(p_abstract));
 
    s.put_raw('>');
    s.put_raw('\n');
 
    if (p_super_classes)
      for (const auto& i : *p_super_classes) {
        s.put_raw(' ');
        s.put_raw(' ');
        s.put_start_tag(superclass_xml_attr, sizeof(superclass_xml_attr) - 1);
        s.put_attribute(name_xml_attr, sizeof(name_xml_attr) - 1, i->c_str());
        s.put_end_tag();
      }
 
    if (p_attributes)
      for (const auto& i : *p_attributes)
        i->save(s);
 
    if (p_relationships)
      for (const auto& i : *p_relationships)
        i->save(s);
 
    if (p_methods)
      for (const auto& i : *p_methods)
        i->save(s);
 
    s.put_raw(' ');
    s.put_last_tag(class_xml_tag, sizeof(class_xml_tag) - 1);
    s.put_raw('\n');
  }
 
  catch (oks::exception& e) {
    throw oks::FailedSave("oks-class", p_name, e);
  }
 
  catch (std::exception& e) {
    throw oks::FailedSave("oks-class", p_name, e.what());
  }
}
 
OksClass::OksClass(OksXmlInputStream& s, OksKernel* k)
  : p_super_classes(0)
  , p_attributes(0)
  , p_relationships(0)
  , p_methods(0)
  , p_abstract(false)
  , p_transient(false)
  , p_to_be_deleted(false)
  , p_all_super_classes(0)
  , p_all_sub_classes(0)
  , p_all_attributes(0)
  , p_all_relationships(0)
  , p_all_methods(0)
  , p_inheritance_hierarchy(0)
  , p_kernel(k)
  , p_instance_size(0)
  , p_data_info(0)
  , p_objects(0)
  , p_indices(0)
{
 
  // read 'relationship' tag header
 
  {
    try {
      const char* tag_start = s.get_tag_start();
 
      if (strcmp(tag_start, class_xml_tag)) {
        if (!strcmp(tag_start, "/oks-schema")) {
          goto end_of_stream; // re-throw of exception takes too much time; go to is better
        }
        s.throw_unexpected_tag(tag_start, class_xml_tag);
      }
    } catch (oks::exception& e) {
      throw oks::FailedRead("oks-class tag", e);
    } catch (std::exception& e) {
      throw oks::FailedRead("oks-class tag", e.what());
    }
  }
 
  // read class attributes
 
  try {
    while (true) {
      OksXmlAttribute attr(s);
 
      // check for close of tag
 
      if (oks::cmp_str1(attr.name(), ">")) {
        break;
      }
 
      // check for known oks-class' attributes
 
      else if (oks::cmp_str4(attr.name(), name_xml_attr))
        p_name.assign(attr.value(), attr.value_len());
      else if (oks::cmp_str11(attr.name(), description_xml_attr))
        p_description.assign(attr.value(), attr.value_len());
      else if (oks::cmp_str11(attr.name(), is_abstract_xml_attr))
        p_abstract = oks::xml::str2bool(attr.value());
      else {
        s.throw_unexpected_tag(attr.name(), "oks-class\' attribute");
      }
    }
  } catch (oks::exception& e) {
    throw oks::FailedRead("oks-class description", e);
  } catch (std::exception& e) {
    throw oks::FailedRead("oks-class description", e.what());
  }
 
  try {
    oks::validate_not_empty(p_name, "class name");
  } catch (std::exception& ex) {
    throw oks::FailedRead("oks class", oks::BadFileData(ex.what(), s.get_line_no(), s.get_line_pos()));
  }
 
  // read class body
 
  while (true) {
 
    try {
 
      const char* tag_start = s.get_tag_start();
 
      // check for closing tag and exit loop
 
      if (oks::cmp_str6(tag_start, "/class")) {
        break;
      }
 
      // create superclass
 
      else if (oks::cmp_str10(tag_start, superclass_xml_attr)) {
        unsigned long scl_pos = s.get_line_no();
        try {
          OksXmlAttribute attr(s);
 
          if (!p_super_classes)
            p_super_classes = new std::list<std::string*>();
          std::string* scl = new std::string(attr.value(), attr.value_len());
          if (has_direct_super_class(*scl)) {
            std::ostringstream text;
            text << "second inclusion of super-class \"" + *scl + "\" at line " << scl_pos;
            delete scl;
            throw std::runtime_error(text.str().c_str());
          }
          p_super_classes->push_back(scl);
 
          OksXmlAttribute attr2(s);
        } catch (oks::exception& e) {
          throw oks::FailedRead(std::string("a superclass-name of class \"") + p_name + '\"', e);
        } catch (std::exception& e) {
          throw oks::FailedRead(std::string("a superclass-name of class \"") + p_name + '\"', e.what());
        }
      }
 
      // create attribute from stream and check attribute status
 
      else if (oks::cmp_str9(tag_start, "attribute")) {
        unsigned long attr_pos = s.get_line_no();
        try {
          if (!p_attributes)
            p_attributes = new std::list<OksAttribute*>();
          OksAttribute* a = new OksAttribute(s, this);
          if (find_direct_attribute(a->get_name()) != nullptr) {
            std::ostringstream text;
            text << "redefinition of attribute with name \"" + a->get_name() + "\" at line " << attr_pos;
            delete a;
            throw std::runtime_error(text.str().c_str());
          }
          p_attributes->push_back(a);
        } catch (oks::exception& e) {
          throw oks::FailedRead(std::string("an attribute of class \"") + p_name + '\"', e);
        } catch (std::exception& e) {
          throw oks::FailedRead(std::string("an attribute of class \"") + p_name + '\"', e.what());
        }
      }
 
      // create relationship from stream and check relationship status
 
      else if (oks::cmp_str12(tag_start, "relationship")) {
        unsigned long rel_pos = s.get_line_no();
        try {
          if (!p_relationships)
            p_relationships = new std::list<OksRelationship*>();
          OksRelationship* r = new OksRelationship(s, this);
          if (find_direct_relationship(r->get_name()) != nullptr) {
            std::ostringstream text;
            text << "redefinition of relationship with name \"" + r->get_name() + "\" at line " << rel_pos;
            delete r;
            throw std::runtime_error(text.str().c_str());
          }
          p_relationships->push_back(r);
        } catch (oks::exception& e) {
          throw oks::FailedRead(std::string("a relationship of class \"") + p_name + '\"', e);
        } catch (std::exception& e) {
          throw oks::FailedRead(std::string("a relationship of class \"") + p_name + '\"', e.what());
        }
      }
 
      // create method from stream and check method status
 
      else if (oks::cmp_str6(tag_start, "method")) {
        unsigned long method_pos = s.get_line_no();
        try {
          if (!p_methods)
            p_methods = new std::list<OksMethod*>();
          OksMethod* m = new OksMethod(s, this);
          if (find_direct_method(m->get_name()) != nullptr) {
            std::ostringstream text;
            text << "redefinition of method with name \"" + m->get_name() + "\" at line " << method_pos;
            delete m;
            throw std::runtime_error(text.str().c_str());
          }
          p_methods->push_back(m);
        } catch (oks::exception& e) {
          throw oks::FailedRead(std::string("a method of class \"") + p_name + '\"', e);
        } catch (std::exception& e) {
          throw oks::FailedRead(std::string("a method of class \"") + p_name + '\"', e.what());
        }
      }
 
      // report error if red something differnt from above
      // and set bad status of constructor (suppose 'name' can't be empty)
 
      else {
        s.throw_unexpected_tag(tag_start);
      }
 
    } catch (oks::FailedRead& e) {
      throw; // re-throw attribute, relationship or method exception
    } catch (oks::exception& e) {
      throw oks::FailedRead(std::string("a tag of class \"") + p_name + '\"', e);
    } catch (std::exception& e) {
      throw oks::FailedRead(std::string("a tag of class \"") + p_name + '\"', e.what());
    }
  }
 
  return;
 
end_of_stream:
 
  throw oks::EndOfXmlStream("oks-schema");
}
 
/******************************************************************************/
/****************************** OKS SUPERCLASSES ******************************/
/******************************************************************************/
 
OksClass*
OksClass::find_super_class(const std::string& nm) const noexcept
{
  if (p_all_super_classes && !p_all_super_classes->empty()) {
    for (FList::const_iterator i = p_all_super_classes->begin(); i != p_all_super_classes->end(); ++i) {
      if ((*i)->get_name() == nm)
        return *i;
    }
  }
 
  return 0;
}
 
bool
OksClass::has_direct_super_class(const std::string& nm) const noexcept
{
  if (p_super_classes) {
    for (std::list<std::string*>::const_iterator i = p_super_classes->begin(); i != p_super_classes->end(); ++i)
      if (nm == *(*i))
        return true;
  }
 
  return false;
}
 
void
OksClass::lock_file(const char* fname)
{
  if (p_kernel) {
    try {
      p_file->lock();
    } catch (oks::exception& ex) {
      throw oks::SetOperationFailed(fname, ex);
    }
  }
}
 
void
OksClass::set_description(const std::string& s)
{
  if (p_description != s) {
    lock_file("OksClass::set_description");
 
    p_description = s;
 
    if (p_kernel) {
      p_file->set_updated();
      if (OksClass::change_notify_fn) {
        (*OksClass::change_notify_fn)(this, ChangeDescription, 0);
      }
    }
  }
}
 
void
OksClass::set_is_abstract(bool b)
{
  if (p_abstract != b) {
    lock_file("OksClass::set_is_abstract");
 
    p_abstract = b;
 
    if (p_kernel) {
      p_file->set_updated();
      if (OksClass::change_notify_fn) {
        (*OksClass::change_notify_fn)(this, ChangeIsAbstaract, 0);
      }
    }
  }
}
 
// Function to report problem with arguments of swap(...) methods
 
static void
check_and_report_empty_parameter(const char* fname, bool b1, bool b2)
{
  if (b1) {
    throw oks::SetOperationFailed(fname, "First parameter is (null)");
  }
 
  if (b2) {
    throw oks::SetOperationFailed(fname, "Second parameter is (null)");
  }
}
 
// Function to report problem with found items of swap(...) methods
 
static void
check_and_report_found_items(const char* fname,
                             const char* item_type,
                             const std::string& item1_name,
                             const std::string& item2_name,
                             const std::string& class_name,
                             bool b1,
                             bool b2)
{
  struct
  {
    bool b;
    const std::string* name;
  } info[] = { { b1, &item1_name }, { b2, &item2_name } };
 
  for (int i = 0; i < 2; ++i) {
    if (info[i].b) {
      std::string text("cannot find direct ");
      text += item_type;
      text += " \"";
      text += *info[i].name;
      text += "\" in class \"";
      text += class_name;
      text += '\"';
      throw oks::SetOperationFailed(fname, text);
    }
  }
}
 
static std::string
add_super_class_error(const std::string& c1, const std::string& c2)
{
  return (std::string("cannot add superclass \"") + c1 + "\" to class \"" + c2 + '\"');
}
 
void
OksClass::k_add_super_class(const std::string& nm)
{
  if (!p_super_classes) {
    p_super_classes = new std::list<std::string*>();
  }
 
  p_super_classes->push_back((new std::string(nm)));
}
 
void
OksClass::add_super_class(const std::string& nm)
{
  if (!p_super_classes) {
    p_super_classes = new std::list<std::string*>();
  } else {
    if (has_direct_super_class(nm)) {
      std::string text(add_super_class_error(nm, p_name));
      text += " because class \"" + p_name + "\" already has such superclass.";
      throw oks::SetOperationFailed("OksClass::add_super_class", text);
    }
  }
 
  if (nm == p_name) {
    std::string text(add_super_class_error(nm, p_name));
    text += " because names of classes are the same.";
    throw oks::SetOperationFailed("OksClass::add_super_class", text);
  }
 
  if (p_kernel) {
    OksClass* nmc = p_kernel->find_class(nm);
    if (nmc) {
      if (nmc->has_direct_super_class(p_name)) {
        std::string text(add_super_class_error(nm, p_name));
        text += " because class \"" + nm + "\" is already direct superclass of \"" + p_name + "\".";
        throw oks::SetOperationFailed("OksClass::add_super_class", text);
      } else if (nmc->find_super_class(p_name)) {
        std::string text(add_super_class_error(nm, p_name));
        text += " because class \"" + nm + "\" is already non-direct superclass of \"" + p_name + "\".";
        throw oks::SetOperationFailed("OksClass::add_super_class", text);
      }
    }
  }
 
  lock_file("OksClass::add_super_class");
 
  p_super_classes->push_back((new std::string(nm)));
 
  registrate_class_change(ChangeSuperClassesList, (const void*)&nm);
}
 
static std::string
remove_super_class_error(const std::string& c1, const std::string& c2)
{
  return (std::string("cannot remove superclass \"") + c1 + "\" from class \"" + c2 + '\"');
}
 
void
OksClass::remove_super_class(const std::string& nm)
{
  if (!p_super_classes) {
    std::string text(remove_super_class_error(nm, p_name));
    text += " because class \"" + p_name + "\" has no superclasses at all.";
    throw oks::SetOperationFailed("OksClass::remove_super_class", text);
  }
 
  for (std::list<std::string*>::iterator i = p_super_classes->begin(); i != p_super_classes->end(); ++i) {
    std::string* si(*i);
    if (nm == *si) {
      lock_file("OksClass::remove_super_class");
 
      p_super_classes->erase(i);
      delete si;
 
      if (p_super_classes->empty()) {
        delete p_super_classes;
        p_super_classes = 0;
      }
 
      registrate_class_change(ChangeSuperClassesList, (const void*)&nm);
 
      return;
    }
  }
 
  std::string text(remove_super_class_error(nm, p_name));
  text += " because class \"" + p_name + "\" has no superclass with this name.";
  throw oks::SetOperationFailed("OksClass::remove_super_class", text);
}
 
void
OksClass::swap_super_classes(const std::string& c1, const std::string& c2)
{
  const char* fname = "OksClass::swap_super_classes()";
 
  // if classs are equal, return success
 
  if (c1 == c2)
    return;
 
  // check that an class name is not empty
 
  check_and_report_empty_parameter(fname, c1.empty(), c2.empty());
 
  // find requested classes in the directed classs list
 
  std::list<std::string*>::iterator i1 = p_super_classes->end();
  std::list<std::string*>::iterator i2 = p_super_classes->end();
 
  for (std::list<std::string*>::iterator i = p_super_classes->begin(); i != p_super_classes->end(); ++i) {
    if (*(*i) == c1)
      i1 = i;
    else if (*(*i) == c2)
      i2 = i;
  }
 
  // check that the classes were found
 
  check_and_report_found_items("OksClass::swap_super_classes",
                               "superclass",
                               c1,
                               c2,
                               p_name,
                               (i1 == p_super_classes->end()),
                               (i2 == p_super_classes->end()));
 
  // replace the classs and make notification
 
  lock_file("OksClass::swap_super_classes");
 
  std::string* s1 = *i1;
  std::string* s2 = *i2;
 
  *i1 = s2;
  *i2 = s1;
 
  registrate_class_change(ChangeSuperClassesList, 0);
}
 
/******************************************************************************/
/******************************* OKS ATTRIBUTES *******************************/
/******************************************************************************/
 
OksAttribute*
OksClass::find_direct_attribute(const std::string& _name) const noexcept
{
  if (p_attributes) {
    for (std::list<OksAttribute*>::const_iterator i = p_attributes->begin(); i != p_attributes->end(); ++i)
      if (_name == (*i)->get_name())
        return *i;
  }
 
  return 0;
}
 
OksAttribute*
OksClass::find_attribute(const std::string& _name) const noexcept
{
  if (p_all_attributes) {
    for (std::list<OksAttribute*>::const_iterator i = p_all_attributes->begin(); i != p_all_attributes->end(); ++i)
      if (_name == (*i)->get_name())
        return *i;
 
    return 0;
  } else
    return find_direct_attribute(_name);
}
 
void
OksClass::k_add(OksAttribute* attribute)
{
  if (!p_attributes) {
    p_attributes = new std::list<OksAttribute*>();
  }
 
  p_attributes->push_back(attribute);
  attribute->p_class = this;
}
 
void
OksClass::add(OksAttribute* attribute)
{
  const char* fname = "OksClass::add(OksAttribute *)";
 
  if (!p_attributes) {
    p_attributes = new std::list<OksAttribute*>();
  } else {
    if (find_direct_attribute(attribute->get_name()) != 0) {
      std::ostringstream text;
      text << "cannot add attribute \"" << attribute->get_name() << "\" to class \"" << p_name
           << "\"\n"
              "because the class already has attribute with this name.\n";
      throw oks::SetOperationFailed(fname, text.str());
    }
  }
 
  lock_file("OksClass::add[OksAttribute]");
 
  p_attributes->push_back(attribute);
  attribute->p_class = this;
 
  registrate_class_change(ChangeAttributesList, (const void*)attribute);
}
 
void
OksClass::swap(const OksAttribute* a1, const OksAttribute* a2)
{
  const char* fname = "OksClass::swap(const OksAttribute *, const OksAttribute *)";
 
  // if attributes are equal, return success
 
  if (a1 == a2)
    return;
 
  // check that an attributes is not (null)
 
  check_and_report_empty_parameter(fname, (a1 == 0), (a2 == 0));
 
  // find requested attributes in the directed attributes list
 
  std::list<OksAttribute*>::iterator i1 = p_attributes->end();
  std::list<OksAttribute*>::iterator i2 = p_attributes->end();
 
  for (std::list<OksAttribute*>::iterator i = p_attributes->begin(); i != p_attributes->end(); ++i) {
    if ((*i) == a1)
      i1 = i;
    else if ((*i) == a2)
      i2 = i;
  }
 
  // check that the attributes were found
 
  check_and_report_found_items(fname,
                               "attribute",
                               a1->get_name(),
                               a2->get_name(),
                               p_name,
                               (i1 == p_attributes->end()),
                               (i2 == p_attributes->end()));
 
  // check that the file can be locked
 
  lock_file("OksClass::swap[OksAttribute]");
 
  // replace the attributes and make notification
 
  *i1 = const_cast<OksAttribute*>(a2);
  *i2 = const_cast<OksAttribute*>(a1);
 
  registrate_class_change(ChangeAttributesList, 0);
}
 
void
OksClass::remove(const OksAttribute* attribute)
{
  const char* fname = "OksClass::remove(OksAttribute *)";
 
  if (!p_attributes) {
    std::ostringstream text;
    text << "cannot remove attribute \"" << attribute->get_name() << "\" from class \"" << p_name
         << "\"\n"
            "because the class has no attributes.\n";
    throw oks::SetOperationFailed(fname, text.str());
  }
 
  for (std::list<OksAttribute*>::iterator i = p_attributes->begin(); i != p_attributes->end(); ++i) {
    if (attribute == *i) {
      lock_file("OksClass::remove[OksAttribute]");
 
      p_attributes->erase(i);
      delete const_cast<OksAttribute*>(attribute);
 
      if (p_attributes->empty()) {
        delete p_attributes;
        p_attributes = 0;
      }
 
      registrate_class_change(ChangeAttributesList, 0);
 
      return;
    }
  }
 
  std::ostringstream text;
  text << "cannot remove attribute \"" << attribute->get_name() << "\" from class \"" << p_name
       << "\"\n"
          "because the class has no such attribute with this name.\n";
  throw oks::SetOperationFailed(fname, text.str());
}
 
OksClass*
OksClass::source_class(const OksAttribute* a) const noexcept
{
  return a->p_class;
}
 
/******************************************************************************/
/***************************** OKS  RELATIONSHIPS *****************************/
/******************************************************************************/
 
OksRelationship*
OksClass::find_direct_relationship(const std::string& _name) const noexcept
{
  if (p_relationships) {
    for (std::list<OksRelationship*>::const_iterator i = p_relationships->begin(); i != p_relationships->end(); ++i)
      if (_name == (*i)->get_name())
        return *i;
  }
 
  return 0;
}
 
OksRelationship*
OksClass::find_relationship(const std::string& _name) const noexcept
{
  if (p_all_relationships) {
    for (std::list<OksRelationship*>::const_iterator i = p_all_relationships->begin(); i != p_all_relationships->end();
         ++i)
      if (_name == (*i)->get_name())
        return *i;
 
    return 0;
  } else
    return find_direct_relationship(_name);
}
 
void
OksClass::k_add(OksRelationship* relationship)
{
  if (!p_relationships) {
    p_relationships = new std::list<OksRelationship*>();
  }
 
  p_relationships->push_back(relationship);
  relationship->p_class = this;
}
 
void
OksClass::add(OksRelationship* relationship)
{
  const char* fname = "OksClass::add(OksRelationship *)";
 
  if (!p_relationships) {
    p_relationships = new std::list<OksRelationship*>();
  } else {
    if (find_direct_relationship(relationship->get_name())) {
      std::ostringstream text;
      text << "cannot add relationship \"" << relationship->get_name() << "\" to class \"" << p_name
           << "\"\n"
              "because the class already has relationship with this name.\n";
      throw oks::SetOperationFailed(fname, text.str());
    }
  }
 
  lock_file("OksClass::add[OksRelationship]");
 
  p_relationships->push_back(relationship);
  relationship->p_class = this;
 
  registrate_class_change(ChangeRelationshipsList, (const void*)relationship);
}
 
void
OksClass::remove(const OksRelationship* relationship, bool call_delete)
{
  const char* fname = "OksClass::remove(OksRelationship *)";
 
  if (!p_relationships) {
    std::ostringstream text;
    text << "cannot remove relationship \"" << relationship->get_name() << "\" from class \"" << p_name
         << "\"\n"
            "because the class has no relationships.\n";
    throw oks::SetOperationFailed(fname, text.str());
  }
 
  for (std::list<OksRelationship*>::iterator i = p_relationships->begin(); i != p_relationships->end(); ++i) {
    if (relationship == *i) {
      lock_file("OksClass::remove[OksRelationship]");
 
      p_relationships->erase(i);
      if (call_delete) {
        delete const_cast<OksRelationship*>(relationship);
      }
 
      if (p_relationships->empty()) {
        delete p_relationships;
        p_relationships = 0;
      }
 
      registrate_class_change(ChangeRelationshipsList, 0);
 
      return;
    }
  }
 
  std::ostringstream text;
  text << "cannot remove relationship \"" << relationship->get_name() << "\" from class \"" << p_name
       << "\"\n"
          "because the class has no such relationship with this name.\n";
  throw oks::SetOperationFailed(fname, text.str());
}
 
void
OksClass::swap(const OksRelationship* r1, const OksRelationship* r2)
{
  const char* fname = "OksClass::swap(const OksRelationship *, const OksRelationship *)";
 
  // if relationships are equal, return success
 
  if (r1 == r2)
    return;
 
  // check that an relationships is not (null)
 
  check_and_report_empty_parameter(fname, (r1 == 0), (r2 == 0));
 
  // find requested relationships in the directed relationships list
 
  std::list<OksRelationship*>::iterator i1 = p_relationships->end();
  std::list<OksRelationship*>::iterator i2 = p_relationships->end();
 
  for (std::list<OksRelationship*>::iterator i = p_relationships->begin(); i != p_relationships->end(); ++i) {
    if ((*i) == r1)
      i1 = i;
    else if ((*i) == r2)
      i2 = i;
  }
 
  // check that the relationships were found
 
  check_and_report_found_items(fname,
                               "relationship",
                               r1->get_name(),
                               r2->get_name(),
                               p_name,
                               (i1 == p_relationships->end()),
                               (i2 == p_relationships->end()));
 
  // check that the file can be locked
 
  lock_file("OksClass::swap[OksRelationship]");
 
  // replace the relationships and make notification
 
  *i1 = const_cast<OksRelationship*>(r2);
  *i2 = const_cast<OksRelationship*>(r1);
 
  registrate_class_change(ChangeRelationshipsList, 0);
}
 
OksClass*
OksClass::source_class(const OksRelationship* r) const noexcept
{
  return r->p_class;
}
 
/******************************************************************************/
/******************************** OKS  METHODS ********************************/
/******************************************************************************/
 
OksMethod*
OksClass::find_direct_method(const std::string& _name) const noexcept
{
  if (p_methods) {
    for (std::list<OksMethod*>::const_iterator i = p_methods->begin(); i != p_methods->end(); ++i)
      if (_name == (*i)->get_name())
        return *i;
  }
 
  return 0;
}
 
OksMethod*
OksClass::find_method(const std::string& _name) const noexcept
{
  if (p_all_methods) {
    for (std::list<OksMethod*>::const_iterator i = p_all_methods->begin(); i != p_all_methods->end(); ++i)
      if (_name == (*i)->get_name())
        return *i;
 
    return 0;
  } else
    return find_direct_method(_name);
}
 
void
OksClass::add(OksMethod* method)
{
  const char* fname = "OksClass::add(OksMethod *)";
 
  if (!p_methods) {
    p_methods = new std::list<OksMethod*>();
  } else {
    if (find_direct_method(method->get_name())) {
      std::ostringstream text;
      text << "cannot add method \"" << method->get_name() << "\" to class \"" << p_name
           << "\"\n"
              "because the class already has method with this name.\n";
      throw oks::SetOperationFailed(fname, text.str());
    }
  }
 
  // check that the file can be locked
 
  lock_file("OksClass::add[OksMethod]");
 
  p_methods->push_back(method);
  method->p_class = this;
 
  registrate_class_change(ChangeMethodsList, (const void*)method);
}
 
void
OksClass::remove(const OksMethod* method)
{
  const char* fname = "OksClass::remove(OksMethod *)";
 
  if (!p_methods) {
    std::ostringstream text;
    text << "cannot remove method \"" << method->get_name() << "\" from class \"" << p_name
         << "\"\n"
            "because the class has no methods.\n";
    throw oks::SetOperationFailed(fname, text.str());
  }
 
  for (std::list<OksMethod*>::iterator i = p_methods->begin(); i != p_methods->end(); ++i) {
    if (method == *i) {
      lock_file("OksClass::remove[OksMethod]");
 
      p_methods->erase(i);
      delete const_cast<OksMethod*>(method);
 
      if (p_methods->empty()) {
        delete p_methods;
        p_methods = 0;
      }
 
      registrate_class_change(ChangeMethodsList, 0);
 
      return;
    }
  }
 
  std::ostringstream text;
  text << "cannot remove method \"" << method->get_name() << "\" from class \"" << p_name
       << "\"\n"
          "because the class has no such method with this name.\n";
  throw oks::SetOperationFailed(fname, text.str());
}
 
void
OksClass::swap(const OksMethod* m1, const OksMethod* m2)
{
  const char* fname = "OksClass::swap(const OksMethod *, const OksMethod *)";
 
  // if methods are equal, return success
 
  if (m1 == m2)
    return;
 
  // check that an methods is not (null)
 
  check_and_report_empty_parameter(fname, (m1 == 0), (m2 == 0));
 
  // find requested methods in the directed methods list
 
  std::list<OksMethod*>::iterator i1 = p_methods->end();
  std::list<OksMethod*>::iterator i2 = p_methods->end();
 
  for (std::list<OksMethod*>::iterator i = p_methods->begin(); i != p_methods->end(); ++i) {
    if ((*i) == m1)
      i1 = i;
    else if ((*i) == m2)
      i2 = i;
  }
 
  // check that the methods were found
 
  check_and_report_found_items(
    fname, "method", m1->get_name(), m2->get_name(), p_name, (i1 == p_methods->end()), (i2 == p_methods->end()));
 
  // check that the file can be locked
 
  lock_file("OksClass::swap[OksMethod]");
 
  // replace the methods and make notification
 
  *i1 = const_cast<OksMethod*>(m2);
  *i2 = const_cast<OksMethod*>(m1);
 
  registrate_class_change(ChangeMethodsList, 0);
}
 
OksClass*
OksClass::source_class(const OksMethod* m) const noexcept
{
  return m->p_class;
}
 
/******************************************************************************/
/******************************** OKS  OBJECTS ********************************/
/******************************************************************************/
 
size_t
OksClass::number_of_objects() const noexcept
{
  return (!p_objects ? 0 : p_objects->size());
}
 
//
// Creates list of class instances and instances of
// all subclasses
//
 
std::list<OksObject*>*
OksClass::create_list_of_all_objects() const noexcept
{
  std::list<OksObject*>* olist = 0;
 
  // add instances of class
 
  if (p_objects && !p_objects->empty()) {
    olist = new std::list<OksObject*>();
 
    for (OksObject::Map::const_iterator i = p_objects->begin(); i != p_objects->end(); ++i)
      olist->push_back((*i).second);
  }
 
  // build iterator over subclasses
 
  if (p_all_sub_classes) {
    for (FList::const_iterator j = p_all_sub_classes->begin(); j != p_all_sub_classes->end(); ++j) {
      OksClass* sc = *j;
 
      // add instances of subclass
 
      if (sc->p_objects && !sc->p_objects->empty()) {
        if (!olist)
          olist = new std::list<OksObject*>();
 
        for (OksObject::Map::const_iterator i = sc->p_objects->begin(); i != sc->p_objects->end(); ++i)
          olist->push_back((*i).second);
      }
    }
  }
 
  return olist;
}
 
OksObject*
OksClass::get_object(const std::string& id) const noexcept
{
  std::shared_lock lock(p_mutex); // protect p_objects
 
  if (p_objects) {
    OksObject::Map::const_iterator i = p_objects->find(&id);
    if (i != p_objects->end())
      return i->second;
  }
 
  return nullptr;
}
 
/******************************************************************************/
/****************************** PRIVATE  METHODS ******************************/
/******************************************************************************/
 
void
OksClass::add(OksObject* object)
{
  std::unique_lock lock(p_mutex); // protect p_objects
 
  if (!p_objects->insert(std::pair<const std::string*, OksObject*>(&object->uid.object_id, object)).second) {
    throw oks::ObjectOperationFailed(*this, object->uid.object_id, "add", "object already exists");
  }
}
 
void
OksClass::remove(OksObject* object)
{
  std::unique_lock lock(p_mutex); // protect p_objects
 
  if (!p_objects) {
    throw oks::ObjectOperationFailed(*this, object->uid.object_id, "remove", "OKS Kernel is not inited");
  }
 
  OksObject::Map::iterator i = p_objects->find(&object->uid.object_id);
 
  if (i != p_objects->end())
    p_objects->erase(i);
  else {
    throw oks::ObjectOperationFailed(*this, object->uid.object_id, "remove", "object does not exist");
  }
}
 
inline void
add_if_not_found(OksClass::FList& clist, OksClass* c)
{
  for (OksClass::FList::const_iterator i = clist.begin(); i != clist.end(); ++i) {
    if (*i == c)
      return;
  }
  clist.push_back(c);
}
 
void
OksClass::add_super_classes(FList* clist) const
{
  if (p_super_classes) {
    for (std::list<std::string*>::const_iterator i = p_super_classes->begin(); i != p_super_classes->end(); ++i) {
      if (OksClass* c = p_kernel->find_class(**i)) {
        c->add_super_classes(clist);
        add_if_not_found(*clist, c);
      } else {
        throw oks::CannotFindSuperClass(*this, **i);
      }
    }
  }
}
 
void
OksClass::create_super_classes()
{
  if (!p_all_super_classes)
    p_all_super_classes = new FList();
  else
    p_all_super_classes->clear();
 
  add_super_classes(p_all_super_classes);
 
#ifndef ERS_NO_DEBUG
  if (ers::debug_level() >= 5) {
    std::ostringstream text;
    text << "found " << p_all_super_classes->size() << " superclass(es) in class \'" << get_name() << "\':\n";
    if (p_all_super_classes->size()) {
      for (FList::iterator i = p_all_super_classes->begin(); i != p_all_super_classes->end(); ++i) {
        text << " - class \'" << (*i)->get_name() << "\'\n";
      }
    }
 
    TLOG_DEBUG(5) << text.str();
  }
#endif
}
 
void
OksClass::create_sub_classes()
{
  if (!p_all_sub_classes)
    p_all_sub_classes = new FList();
  else
    p_all_sub_classes->clear();
 
  if (!p_kernel->p_classes.empty()) {
    for (Map::iterator i = p_kernel->p_classes.begin(); i != p_kernel->p_classes.end(); ++i) {
      OksClass* c = i->second;
 
      if (const FList* scl = c->p_all_super_classes) {
        for (FList::const_iterator j = scl->begin(); j != scl->end(); ++j) {
          if (*j == this) {
            p_all_sub_classes->push_back(c);
            break;
          }
        }
      }
    }
  }
}
 
inline const char*
bool2value_type(bool v)
{
  return (v ? "multi-value" : "single-value");
}
 
// skip differency between enum and string
 
inline bool
are_types_different(const OksAttribute* a1, const OksAttribute* a2)
{
  static const std::string __enum_str__("enum");
  static const std::string __string_str__("string");
 
  const std::string& s1 = a1->get_type();
  const std::string& s2 = a2->get_type();
 
  return (
    !((s1 == s2) || ((s1 == __enum_str__ && s2 == __string_str__) || (s1 == __string_str__ && s2 == __enum_str__))));
}
 
void
OksClass::create_attributes()
{
  if (p_attributes)
    for (const auto& x : *p_attributes)
      x->set_init_data();
 
  if (!p_all_attributes)
    p_all_attributes = new std::list<OksAttribute*>();
  else
    p_all_attributes->clear();
 
  if (p_all_super_classes) {
    for (FList::iterator i = p_all_super_classes->begin(); i != p_all_super_classes->end(); ++i) {
      OksClass* c(*i);
      if (c->p_attributes) {
        for (std::list<OksAttribute*>::iterator i2 = c->p_attributes->begin(); i2 != c->p_attributes->end(); ++i2) {
          OksAttribute* a(*i2);
          OksAttribute* a1 = find_direct_attribute(a->get_name());
          OksAttribute* a2 = find_attribute(a->get_name());
          if (a1 == 0 && a2 == 0) {
            p_all_attributes->push_back(a);
          } else if (!p_kernel->p_silence) {
            if (a1) {
              TLOG_DEBUG(1) << "in class \'" << get_name() << "\' direct attribute \'" << a1->get_name()
                            << "\' overrides one coming from superclass \'" << a->p_class->get_name() << '\'';
              if (are_types_different(a1, a)) {
                Oks::warning_msg("OksClass::create_attributes()")
                  << "  found attribute \'" << a->get_name() << "\' types conflict in class \'" << get_name() << "\':\n"
                  << "  type of attribute in superclass \'" << a->p_class->get_name() << "\' is \'" << a->get_type()
                  << "\'\n"
                  << "  type of attribute in class \'" << get_name() << "\' is \'" << a1->get_type() << "\'\n";
              }
 
              if (a1->get_is_multi_values() != a->get_is_multi_values()) {
                Oks::warning_msg("OksClass::create_attributes()")
                  << "  found attribute \'" << a->get_name() << "\' types conflict in class \'" << get_name() << "\':\n"
                  << "  attribute in superclass \'" << a->p_class->get_name() << "\' is "
                  << bool2value_type(a->get_is_multi_values()) << "\n"
                  << "  attribute in class \'" << get_name() << "\' is \'" << bool2value_type(a1->get_is_multi_values())
                  << "\'\n";
              }
            } else if (a2) {
              TLOG_DEBUG(1) << "in class \'" << get_name() << "\' attribute \'" << a2->get_name()
                            << "\' from superclass \'" << a2->p_class->get_name()
                            << "\' overrides one coming from superclass \'" << a->p_class->get_name() << '\'';
              if (are_types_different(a2, a)) {
                Oks::warning_msg("OksClass::create_attributes()")
                  << "  found attribute \'" << a->get_name() << "\' types conflict in class \'" << get_name() << "\':\n"
                  << "  type of attribute in superclass \'" << a->p_class->get_name() << "\' is \'" << a->get_type()
                  << "\'\n"
                  << "  type of attribute in superclass \'" << a2->p_class->get_name() << "\' is \'" << a2->get_type()
                  << "\'\n";
              }
 
              if (a2->get_is_multi_values() != a->get_is_multi_values()) {
                Oks::warning_msg("OksClass::create_attributes()")
                  << "  found attribute \'" << a->get_name() << "\' types conflict in class \'" << get_name() << "\':\n"
                  << "  attribute in superclass \'" << a->p_class->get_name() << "\' is "
                  << bool2value_type(a->get_is_multi_values()) << "\n"
                  << "  attribute in superclass \'" << get_name() << "\' is \'"
                  << bool2value_type(a2->get_is_multi_values()) << "\'\n";
              }
            }
          }
        }
      }
    }
  }
 
  if (p_attributes) {
    for (std::list<OksAttribute*>::iterator i = p_attributes->begin(); i != p_attributes->end(); ++i) {
      p_all_attributes->push_back(*i);
    }
  }
}
 
inline const char*
card2string(OksRelationship::CardinalityConstraint cc)
{
  return (cc == OksRelationship::One ? "one object" : "many objects");
}
 
void
OksClass::create_relationships()
{
  if (!p_all_relationships)
    p_all_relationships = new std::list<OksRelationship*>();
  else
    p_all_relationships->clear();
 
  if (p_all_super_classes) {
    for (FList::iterator i = p_all_super_classes->begin(); i != p_all_super_classes->end(); ++i) {
      OksClass* c(*i);
      if (c->p_relationships) {
        for (std::list<OksRelationship*>::iterator i2 = c->p_relationships->begin(); i2 != c->p_relationships->end();
             ++i2) {
          OksRelationship* r = *i2;
          OksRelationship* r1 = find_direct_relationship(r->get_name());
          OksRelationship* r2 = find_relationship(r->get_name());
 
          if (!r->p_class_type) {
            r->p_class_type = p_kernel->find_class(r->p_rclass);
          }
 
          if (r1 == 0 && r2 == 0) {
            p_all_relationships->push_back(r);
          } else {
            if (r1) {
              TLOG_DEBUG(1) << "in class \'" << get_name() << "\' direct relationship \'" << r1->get_name()
                            << "\' overrides one coming from superclass \'" << r->p_class->get_name() << '\'';
              if (r1->get_high_cardinality_constraint() != r->get_high_cardinality_constraint()) {
                Oks::warning_msg("OksClass::create_relationships()")
                  << "  found relationship \'" << r->get_name() << "\' cardinality conflict in class \'" << get_name()
                  << "\':\n"
                  << "  relationship in superclass \'" << r->p_class->get_name() << "\' allows "
                  << card2string(r->get_high_cardinality_constraint()) << "\n"
                  << "  relationship in class \'" << get_name() << "\' allows "
                  << card2string(r1->get_high_cardinality_constraint()) << std::endl;
              }
            } else if (r2) {
              TLOG_DEBUG(1) << "in class \'" << get_name() << "\' relationship \'" << r2->get_name()
                            << "\' from superclass \'" << r2->p_class->get_name()
                            << "\' overrides one coming from superclass \'" << r->p_class->get_name() << '\'';
              if (r2->get_high_cardinality_constraint() != r->get_high_cardinality_constraint()) {
                Oks::warning_msg("OksClass::create_relationships()")
                  << "  found relationship \'" << r->get_name() << "\' cardinality conflict in class \'" << get_name()
                  << "\':\n"
                  << "  relationship in superclass \'" << r->p_class->get_name() << "\' allows "
                  << card2string(r->get_high_cardinality_constraint()) << "\n"
                  << "  relationship in superclass \'" << r2->p_class->get_name() << "\' allows "
                  << card2string(r2->get_high_cardinality_constraint()) << std::endl;
              }
            }
          }
        }
      }
    }
  }
 
  if (p_relationships) {
    for (std::list<OksRelationship*>::iterator i = p_relationships->begin(); i != p_relationships->end(); ++i) {
      OksRelationship* r = *i;
 
      if (!r->p_class_type) {
        r->p_class_type = p_kernel->find_class(r->p_rclass);
      }
 
      p_all_relationships->push_back(r);
    }
  }
}
 
void
OksClass::create_methods()
{
  if (!p_all_methods)
    p_all_methods = new std::list<OksMethod*>();
  else
    p_all_methods->clear();
 
  if (p_all_super_classes) {
    for (FList::iterator i = p_all_super_classes->begin(); i != p_all_super_classes->end(); ++i) {
      std::list<OksMethod*>::iterator i2;
      if ((*i)->p_methods) {
        for (i2 = (*i)->p_methods->begin(); i2 != (*i)->p_methods->end(); ++i2) {
          if (find_direct_method((*i2)->get_name()) == 0 && find_method((*i2)->get_name()) == 0) {
            p_all_methods->push_back(*i2);
          }
        }
      }
    }
  }
 
  if (p_methods) {
    for (std::list<OksMethod*>::iterator i = p_methods->begin(); i != p_methods->end(); ++i) {
      p_all_methods->push_back(*i);
    }
  }
}
 
// Updates the values of the instances of the class and all their subclasses
// in case of a change of the attribute's type or multi values cardinality
 
void
OksClass::registrate_attribute_change(OksAttribute* a)
{
  OSK_PROFILING(OksProfiler::ClassRegistrateAttributeChange, p_kernel)
 
  FList::iterator i;
  if (p_all_sub_classes)
    i = p_all_sub_classes->begin();
 
  OksClass* c(this);
 
  do {
    if (c->p_objects && !c->p_objects->empty()) {
      for (OksObject::Map::const_iterator i2 = c->p_objects->begin(); i2 != c->p_objects->end(); ++i2) {
        OksObject* o(i2->second);
        OksData newData;
        OksData* oldData = &o->data[((*(c->p_data_info))[a->p_name])->offset];
 
        try {
          oldData->cvt(&newData, a);
          oldData->Clear();
          memcpy(static_cast<void*>(oldData), static_cast<void*>(&newData), sizeof(OksData));
          newData.Clear2(); // Do not free !
        } catch (oks::AttributeReadError& ex) {
          std::ostringstream text;
          text << "attribute \'" << a->get_name() << "\' change converting object " << o << ' ';
          throw oks::CannotRegisterClass(*this, text.str(), ex);
        }
      }
    }
  } while (p_all_sub_classes && i != p_all_sub_classes->end() && (c = *(i++)));
}
 
// Updates the values of the instances of the class and all their subclasses
// in case of a change of the relationship's class type or a cardinality
 
void
OksClass::registrate_relationship_change(OksRelationship* r)
{
  OSK_PROFILING(OksProfiler::ClassRegistrateRelationshipChange, p_kernel)
 
  FList::iterator i;
  if (p_all_sub_classes)
    i = p_all_sub_classes->begin();
 
  OksClass* c(this);
 
  do {
    if (c->p_objects && !c->p_objects->empty()) {
      for (OksObject::Map::const_iterator i2 = c->p_objects->begin(); i2 != c->p_objects->end(); ++i2) {
        OksObject* o(i2->second);
        OksData newData;
        OksData* oldData = &o->data[((*(c->p_data_info))[r->p_name])->offset];
 
        oldData->ConvertTo(&newData, r);
        oldData->Clear();
        memcpy(static_cast<void*>(oldData), static_cast<void*>(&newData), sizeof(OksData));
        newData.Clear2(); // Do not free !
      }
    }
  } while (p_all_sub_classes && i != p_all_sub_classes->end() && (c = *(i++)));
}
 
void
OksClass::registrate_instances()
{
  OSK_PROFILING(OksProfiler::ClassRegistrateInstances, p_kernel)
 
  OksDataInfo::Map* dInfo = new OksDataInfo::Map();
 
  size_t dInfoLength = 0;
  bool thereAreChanges = false;
 
  if (!p_all_attributes->empty()) {
    for (std::list<OksAttribute*>::iterator i = p_all_attributes->begin(); i != p_all_attributes->end(); ++i) {
      OksAttribute* a = *i;
      if (!thereAreChanges) {
        OksDataInfo::Map::const_iterator x = p_data_info->find(a->get_name());
        if (x == p_data_info->end() || x->second->attribute == nullptr || x->second->offset != dInfoLength ||
            !(*(x->second->attribute) == *a)) {
          thereAreChanges = true;
        }
      }
 
      (*dInfo)[a->get_name()] = new OksDataInfo(dInfoLength++, a);
    }
  }
 
  if (!p_all_relationships->empty()) {
    for (std::list<OksRelationship*>::iterator i = p_all_relationships->begin(); i != p_all_relationships->end(); ++i) {
      OksRelationship* r = *i;
      if (!thereAreChanges) {
        OksDataInfo::Map::const_iterator x = p_data_info->find(r->get_name());
        if (x == p_data_info->end() || x->second->relationship == nullptr || x->second->offset != dInfoLength ||
            !(*(x->second->relationship) == *r)) {
          thereAreChanges = true;
        }
      }
 
      (*dInfo)[r->get_name()] = new OksDataInfo(dInfoLength++, r);
    }
  }
 
  if (thereAreChanges == true) {
    if (p_objects && !p_objects->empty()) {
      for (OksObject::Map::const_iterator i = p_objects->begin(); i != p_objects->end(); ++i) {
        OksObject* o = (*i).second;
        OksData* data = new OksData[dInfoLength];
        size_t count = 0;
 
        if (!p_all_attributes->empty()) {
          for (std::list<OksAttribute*>::iterator i2 = p_all_attributes->begin(); i2 != p_all_attributes->end(); ++i2) {
            OksAttribute* a = *i2;
 
            OksDataInfo::Map::const_iterator x = p_data_info->find(a->get_name());
 
            if (x != p_data_info->end() && x->second->attribute) {
              OksData* oldData(&o->data[x->second->offset]);
 
              if (*(x->second->attribute) == *a) {
                memcpy(static_cast<void*>(&data[count++]), static_cast<void*>(oldData), sizeof(OksData));
                oldData->type = OksData::unknown_type;
              } else {
                try {
                  oldData->cvt(&data[count++], a);
                } catch (oks::AttributeReadError& ex) {
                  throw oks::AttributeConversionFailed(*a, o, ex);
                }
              }
            }
          }
        }
 
        if (!p_all_relationships->empty()) {
          for (std::list<OksRelationship*>::iterator i2 = p_all_relationships->begin();
               i2 != p_all_relationships->end();
               ++i2) {
            OksRelationship* r = *i2;
 
            OksDataInfo::Map::const_iterator x = p_data_info->find(r->get_name());
 
            if (x != p_data_info->end() && x->second->relationship) {
              OksData* oldData = &o->data[x->second->offset];
 
              if (*(x->second->relationship) == *r) {
                memcpy(static_cast<void*>(&data[count++]), static_cast<void*>(oldData), sizeof(OksData));
                oldData->type = OksData::unknown_type;
              } else
                oldData->ConvertTo(&data[count++], r);
            }
          }
        }
 
        int n = p_instance_size;
        while (n--)
          o->data[n].Clear();
        delete o->data;
 
        o->data = data;
      }
    }
  }
 
  if (!p_data_info->empty()) {
    for (OksDataInfo::Map::iterator i = p_data_info->begin(); i != p_data_info->end(); ++i) {
      delete i->second;
    }
  }
 
  delete p_data_info;
 
  p_data_info = dInfo;
  p_instance_size = dInfoLength;
}
 
void
OksClass::registrate_class(bool skip_registered)
{
  OSK_PROFILING(OksProfiler::ClassRegistrateClass, p_kernel)
 
  {
    if (!p_data_info)
      p_data_info = new OksDataInfo::Map();
    if (!p_objects) {
      p_objects = new OksObject::Map((p_abstract == false) ? 1024 : 1);
    }
  }
 
  if (!p_data_info->empty() && skip_registered) {
    TLOG_DEBUG(4) << "skip already registered " << get_name();
    return;
  }
 
  try {
    create_super_classes();
    create_attributes();
    create_relationships();
    create_methods();
 
    registrate_instances();
  } catch (oks::exception& ex) {
    throw oks::CannotRegisterClass(*this, "", ex);
  }
}
 
void
OksClass::registrate_class_change(ChangeType changeType, const void* parameter, bool update_file)
{
  if (!p_kernel)
    return;
 
  OSK_PROFILING(OksProfiler::ClassRegistrateClassChange, p_kernel)
 
  try {
    if (update_file)
      p_file->set_updated();
 
    FList superclasses;
 
    if (changeType == ChangeSuperClassesList && !p_all_super_classes->empty())
      for (FList::iterator i2 = p_all_super_classes->begin(); i2 != p_all_super_classes->end(); ++i2) {
        superclasses.push_back(*i2);
      }
 
    FList::iterator i;
    if (p_all_sub_classes)
      i = p_all_sub_classes->begin();
 
    OksClass* c = this;
 
    do {
      switch (changeType) {
        case ChangeSuperClassesList:
          c->create_super_classes();
          c->create_attributes();
          c->create_relationships();
          c->create_methods();
          break;
 
        case ChangeAttributesList:
          c->create_attributes();
          break;
 
        case ChangeRelationshipsList:
          c->create_relationships();
          break;
 
        case ChangeMethodsList:
          c->create_methods();
          break;
 
        default:
          continue;
      }
 
      if (changeType != ChangeMethodsList)
        c->registrate_instances();
    } while (p_all_sub_classes && i != p_all_sub_classes->end() && (c = *(i++)));
 
    if (changeType == ChangeSuperClassesList) {
      if (!p_all_super_classes->empty())
        for (FList::iterator i2 = p_all_super_classes->begin(); i2 != p_all_super_classes->end(); ++i2)
          if (find(superclasses.begin(), superclasses.end(), *i2) == superclasses.end()) {
            superclasses.push_back(*i2);
          }
 
      for (FList::const_iterator i2 = superclasses.begin(); i2 != superclasses.end(); ++i2) {
        c = *i2;
 
        if (p_kernel->is_dangling(c) || c->p_to_be_deleted)
          continue;
 
        c->create_sub_classes();
 
        if (OksClass::change_notify_fn)
          (*OksClass::change_notify_fn)(c, ChangeSubClassesList, 0);
      }
      superclasses.clear();
    }
 
    if (OksClass::change_notify_fn) {
      if (p_all_sub_classes)
        i = p_all_sub_classes->begin();
      c = this;
 
      do
        (*OksClass::change_notify_fn)(c, changeType, parameter);
      while (p_all_sub_classes && i != p_all_sub_classes->end() && (c = *(i++)));
    }
  } catch (oks::exception& ex) {
    throw oks::CannotRegisterClass(*this, "change ", ex);
  }
}
 
bool
OksClass::check_relationships(std::ostringstream& out, bool print_file_name) const noexcept
{
  bool found_problems = false;
 
  if (const std::list<OksRelationship*>* rels = direct_relationships()) {
    for (auto& x : *rels) {
      if (x->get_class_type() == nullptr) {
        if (found_problems == false) {
          found_problems = true;
          out << " * there are problems with class \"" << get_name() << '\"';
          if (print_file_name) {
            out << " from file \"" << get_file()->get_full_file_name() << '\"';
          }
          out << ":\n";
        }
 
        out << "   - class type \"" << x->get_type() << "\" of relationship \"" << x->get_name()
            << "\" is not loaded\n";
      }
    }
  }
 
  return found_problems;
}
 
} // namespace oks
} // namespace dunedaq