relationship.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/relationship.hpp"
#include "oks/class.hpp"
#include "oks/cstring.hpp"
#include "oks/kernel.hpp"
#include "oks/xml.hpp"
 
#include <sstream>
 
namespace dunedaq {
namespace oks {
 
const char OksRelationship::relationship_xml_tag[] = "relationship";
const char OksRelationship::name_xml_attr[] = "name";
const char OksRelationship::description_xml_attr[] = "description";
const char OksRelationship::class_type_xml_attr[] = "class-type";
const char OksRelationship::low_cc_xml_attr[] = "low-cc";
const char OksRelationship::high_cc_xml_attr[] = "high-cc";
const char OksRelationship::is_composite_xml_attr[] = "is-composite";
const char OksRelationship::is_exclusive_xml_attr[] = "is-exclusive";
const char OksRelationship::is_dependent_xml_attr[] = "is-dependent";
const char OksRelationship::ordered_xml_attr[] = "ordered";
 
OksRelationship::CardinalityConstraint
OksRelationship::str2card(const char* s) noexcept
{
  return (oks::cmp_str3(s, "one") ? One : oks::cmp_str4(s, "zero") ? Zero : Many);
}
 
const char*
OksRelationship::card2str(CardinalityConstraint cc) noexcept
{
  return (cc == Zero ? "zero" : cc == One ? "one" : "many");
}
 
OksRelationship::OksRelationship(const std::string& nm, OksClass* p)
  : p_name(nm)
  , p_low_cc(Zero)
  , p_high_cc(Many)
  , p_composite(false)
  , p_exclusive(false)
  , p_dependent(false)
  , p_class(p)
  , p_class_type(nullptr)
  , p_ordered(false)
{
  oks::validate_not_empty(p_name, "relationship name");
}
 
OksRelationship::OksRelationship(const std::string& nm,
                                 const std::string& rc,
                                 CardinalityConstraint l_cc,
                                 CardinalityConstraint h_cc,
                                 bool cm,
                                 bool excl,
                                 bool dp,
                                 const std::string& desc,
                                 OksClass* p)
  : p_name(nm)
  , p_rclass(rc)
  , p_low_cc(l_cc)
  , p_high_cc(h_cc)
  , p_composite(cm)
  , p_exclusive(excl)
  , p_dependent(dp)
  , p_description(desc)
  , p_class(p)
  , p_class_type(nullptr)
  , p_ordered(false)
{
  oks::validate_not_empty(p_name, "relationship name");
  oks::validate_not_empty(p_rclass, "relationship class");
}
 
bool
OksRelationship::operator==(const class OksRelationship& r) const
{
  return ((this == &r) ||
          ((p_name == r.p_name) && (p_rclass == r.p_rclass) && (p_low_cc == r.p_low_cc) && (p_high_cc == r.p_high_cc) &&
           (p_composite == r.p_composite) && (p_exclusive == r.p_exclusive) && (p_dependent == r.p_dependent) &&
           (p_description == r.p_description) && (p_ordered == r.p_ordered)));
}
 
std::ostream&
operator<<(std::ostream& s, const OksRelationship& r)
{
  s << "Relationship name: \"" << r.p_name
    << "\"\n"
       " class type: \""
    << r.p_rclass
    << "\"\n"
       " low cardinality constraint is "
    << OksRelationship::card2str(r.p_low_cc)
    << "\n"
       " high cardinality constraint is "
    << OksRelationship::card2str(r.p_high_cc)
    << "\n"
       " is"
    << (r.p_composite == true ? "" : " not")
    << " composite reference\n"
       " is"
    << (r.p_exclusive == true ? "" : " not")
    << " exclusive reference\n"
       " is "
    << (r.p_dependent == true ? "dependent" : "shared")
    << " reference\n"
       " has description: \""
    << r.p_description
    << "\"\n"
       " is "
    << (r.p_ordered == true ? "ordered" : "unordered") << std::endl;
 
  return s;
}
 
void
OksRelationship::save(OksXmlOutputStream& s) const
{
  s.put("  ");
 
  s.put_start_tag(relationship_xml_tag, sizeof(relationship_xml_tag) - 1);
 
  s.put_attribute(name_xml_attr, sizeof(name_xml_attr) - 1, p_name.c_str());
 
  if (!p_description.empty())
    s.put_attribute(description_xml_attr, sizeof(description_xml_attr) - 1, p_description.c_str());
 
  s.put_attribute(class_type_xml_attr, sizeof(class_type_xml_attr) - 1, p_rclass.c_str());
  s.put_attribute(low_cc_xml_attr, sizeof(low_cc_xml_attr) - 1, card2str(p_low_cc));
  s.put_attribute(high_cc_xml_attr, sizeof(high_cc_xml_attr) - 1, card2str(p_high_cc));
  s.put_attribute(is_composite_xml_attr, sizeof(is_composite_xml_attr) - 1, oks::xml::bool2str(p_composite));
  s.put_attribute(is_exclusive_xml_attr, sizeof(is_exclusive_xml_attr) - 1, oks::xml::bool2str(p_exclusive));
  s.put_attribute(is_dependent_xml_attr, sizeof(is_dependent_xml_attr) - 1, oks::xml::bool2str(p_dependent));
 
  if (p_ordered)
    s.put_attribute(ordered_xml_attr, sizeof(ordered_xml_attr) - 1, oks::xml::bool2str(p_ordered));
 
  s.put_end_tag();
}
 
OksRelationship::OksRelationship(OksXmlInputStream& s, OksClass* parent)
  : p_low_cc(Zero)
  , p_high_cc(Many)
  , p_composite(false)
  , p_exclusive(false)
  , p_dependent(false)
  , p_class(parent)
  , p_class_type(nullptr)
  , p_ordered(false)
{
  try {
    while (true) {
      OksXmlAttribute attr(s);
 
      // check for close of tag
 
      if (oks::cmp_str1(attr.name(), "/")) {
        break;
      }
 
      // check for known oks-relationship' 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_str10(attr.name(), class_type_xml_attr))
        p_rclass.assign(attr.value(), attr.value_len());
      else if (oks::cmp_str6(attr.name(), low_cc_xml_attr))
        p_low_cc = str2card(attr.value());
      else if (oks::cmp_str7(attr.name(), high_cc_xml_attr))
        p_high_cc = str2card(attr.value());
      else if (oks::cmp_str12(attr.name(), is_composite_xml_attr))
        p_composite = oks::xml::str2bool(attr.value());
      else if (oks::cmp_str12(attr.name(), is_exclusive_xml_attr))
        p_exclusive = oks::xml::str2bool(attr.value());
      else if (oks::cmp_str12(attr.name(), is_dependent_xml_attr))
        p_dependent = oks::xml::str2bool(attr.value());
      else if (oks::cmp_str7(attr.name(), ordered_xml_attr))
        p_ordered = oks::xml::str2bool(attr.value());
      else if (!strcmp(attr.name(), "multi-value-implementation")) {
        s.error_msg("OksRelationship::OksRelationship(OksXmlInputStream&)")
          << "Obsolete oks-relationship\'s attribute \'" << attr.name() << "\'\n";
      } else {
        s.throw_unexpected_attribute(attr.name());
      }
    }
  } catch (oks::exception& e) {
    throw oks::FailedRead("xml attribute", e);
  } catch (std::exception& e) {
    throw oks::FailedRead("xml attribute", e.what());
  }
 
  // check validity of read values
 
  try {
    oks::validate_not_empty(p_name, "relationship name");
    oks::validate_not_empty(p_rclass, "relationship class");
  } catch (std::exception& ex) {
    throw oks::FailedRead("oks relationship", oks::BadFileData(ex.what(), s.get_line_no(), s.get_line_pos()));
  }
}
 
void
OksRelationship::set_name(const std::string& new_name)
{
  // ignore when name is the same
 
  if (p_name == new_name)
    return;
 
  // additional checks are required,
  // if the relationship already belongs to some class
 
  if (p_class) {
 
    // check maximum allowed length for relationship name
 
    try {
      oks::validate_not_empty(new_name, "name");
    } catch (std::exception& ex) {
      throw oks::SetOperationFailed("OksRelationship::set_name", ex.what());
    }
 
    // having a direct relationship with the same name is an error
 
    if (p_class->find_direct_relationship(new_name) != 0) {
      std::ostringstream text;
      text << "Class \"" << p_class->get_name() << "\" already has direct relationship \"" << new_name << '\"';
      throw oks::SetOperationFailed("OksRelationship::set_name", text.str());
    }
 
    // check possibility to lock the file
 
    p_class->lock_file("OksRelationship::set_name");
 
    // probably a non-direct relationship already exists
 
    OksRelationship* r = p_class->find_relationship(new_name);
 
    // change the name
 
    p_name = new_name;
 
    // registrate the change
 
    p_class->registrate_class_change(OksClass::ChangeRelationshipsList, (const void*)r);
  } else {
    p_name = new_name;
  }
}
 
void
OksRelationship::set_type(const std::string& cn)
{
  if (p_rclass == cn)
    return;
 
  if (!p_class || !p_class->p_kernel || (p_class_type = p_class->p_kernel->find_class(cn)) != 0) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_type");
 
    p_rclass = cn;
 
    if (p_class) {
      p_class->registrate_class_change(OksClass::ChangeRelationshipClassType, (const void*)this);
      p_class->registrate_relationship_change(this);
    }
  } else {
    std::ostringstream text;
    text << "cannot find class \"" << cn << '\"';
    throw oks::SetOperationFailed("OksRelationship::set_type", text.str());
  }
}
 
void
OksRelationship::set_description(const std::string& desc)
{
  if (p_description != desc) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_description");
 
    p_description = desc;
 
    if (p_class)
      p_class->registrate_class_change(OksClass::ChangeRelationshipDescription, (const void*)this);
  }
}
 
void
OksRelationship::set_low_cardinality_constraint(CardinalityConstraint l_cc)
{
  if (p_low_cc != l_cc) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_low_cardinality_constraint");
 
    CardinalityConstraint old_cc = p_low_cc;
 
    p_low_cc = l_cc;
 
    if (p_class) {
      p_class->registrate_class_change(OksClass::ChangeRelationshipLowCC, (const void*)this);
 
      if (p_low_cc == Many || old_cc == Many)
        p_class->registrate_relationship_change(this);
    }
  }
}
 
void
OksRelationship::set_high_cardinality_constraint(CardinalityConstraint h_cc)
{
  if (p_high_cc != h_cc) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_high_cardinality_constraint");
 
    CardinalityConstraint old_cc = p_high_cc;
 
    p_high_cc = h_cc;
 
    if (p_class) {
      p_class->registrate_class_change(OksClass::ChangeRelationshipHighCC, (const void*)this);
 
      if (p_high_cc == Many || old_cc == Many)
        p_class->registrate_relationship_change(this);
    }
  }
}
 
void
OksRelationship::set_is_composite(bool cm)
{
  if (p_composite != cm) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_is_composite");
 
    p_composite = cm;
 
    if (p_class)
      p_class->registrate_class_change(OksClass::ChangeRelationshipComposite, (const void*)this);
  }
}
 
void
OksRelationship::set_is_exclusive(bool ex)
{
  if (p_exclusive != ex) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_is_exclusive");
 
    p_exclusive = ex;
 
    if (p_class)
      p_class->registrate_class_change(OksClass::ChangeRelationshipExclusive, (const void*)this);
  }
}
 
void
OksRelationship::set_is_dependent(bool dp)
{
  if (p_dependent != dp) {
    if (p_class)
      p_class->lock_file("OksRelationship::set_is_dependent");
 
    p_dependent = dp;
 
    if (p_class)
      p_class->registrate_class_change(OksClass::ChangeRelationshipDependent, (const void*)this);
  }
}
 
} // namespace oks
} // namespace dunedaq