dunedaq::oks::OksRelationship Class Reference

#include <relationship.hpp>

Collaboration diagram for dunedaq::oks::OksRelationship:

Public Types
enum	CardinalityConstraint { Zero , One , Many }

Public Member Functions
	OksRelationship (const std::string &name, OksClass *p=nullptr)
	OKS relationship simple constructor.
	OksRelationship (const std::string &name, const std::string &type, CardinalityConstraint low_cc, CardinalityConstraint high_cc, bool composite, bool exclusive, bool dependent, const std::string &description, OksClass *p=nullptr)
	OKS relationship complete constructor.
bool	operator== (const class OksRelationship &) const
const std::string &	get_name () const noexcept
void	set_name (const std::string &)
	Set relationship name.
OksClass *	get_class_type () const noexcept
const std::string &	get_type () const noexcept
void	set_type (const std::string &type)
	Set relationship type.
const std::string &	get_description () const noexcept
void	set_description (const std::string &description)
	Set relationship description.
CardinalityConstraint	get_low_cardinality_constraint () const noexcept
	Get relationship low cardinality constraint.
void	set_low_cardinality_constraint (CardinalityConstraint cc)
	Set relationship low cardinality constraint.
CardinalityConstraint	get_high_cardinality_constraint () const noexcept
	Get relationship high cardinality constraint.
void	set_high_cardinality_constraint (CardinalityConstraint)
	Set relationship high cardinality constraint.
bool	get_is_composite () const noexcept
void	set_is_composite (bool composite)
	Set the composite relationship property.
bool	get_is_exclusive () const noexcept
void	set_is_exclusive (bool exclusive)
	Set the composite relationship exclusive property.
bool	get_is_dependent () const noexcept
void	set_is_dependent (bool dependent)
	Set the composite relationship dependent property.

Static Public Member Functions
static CardinalityConstraint	str2card (const char *) noexcept
static const char *	card2str (CardinalityConstraint) noexcept

Private Member Functions
	OksRelationship (OksXmlInputStream &, OksClass *)
void	save (OksXmlOutputStream &) const
	private constructor from XML stream

Private Attributes
std::string	p_name
std::string	p_rclass
CardinalityConstraint	p_low_cc
CardinalityConstraint	p_high_cc
bool	p_composite
bool	p_exclusive
bool	p_dependent
std::string	p_description
OksClass *	p_class
OksClass *	p_class_type
bool	p_ordered

Static Private Attributes
static const char	relationship_xml_tag [] = "relationship"
	private method to save in XML stream
static const char	name_xml_attr [] = "name"
static const char	description_xml_attr [] = "description"
static const char	class_type_xml_attr [] = "class-type"
static const char	low_cc_xml_attr [] = "low-cc"
static const char	high_cc_xml_attr [] = "high-cc"
static const char	is_composite_xml_attr [] = "is-composite"
static const char	is_exclusive_xml_attr [] = "is-exclusive"
static const char	is_dependent_xml_attr [] = "is-dependent"
static const char	mv_implement_xml_attr []
static const char	ordered_xml_attr [] = "ordered"

Friends
class	OksKernel
class	OksClass
struct	OksData
class	OksObject
std::ostream &	operator<< (std::ostream &s, const OksRelationship &r)

Detailed Description

  @ingroup oks

\brief OKS relationship class.

    The class implements OKS relationship that is a part of an OKS class.

    A relationship has name, class type and description.
    A relationship is [zero|one]-to-one or [zero|one]-to-many.

  There are two basic types of OKS relationships:
  - \b weak or \b general reference (relationship): default reference between two objects, it carries no special

semantic;

• strong or composite reference (relationship): the objects connected by composite references are considered as a whole object.

    A composite reference may be exclusive or shared
    (an exclusive object is component of only one object,
    a shared object may be referenced by more than one object).
  
    As well a composite reference can be dependent or independent.
    The existence of object, referenced thought dependent composite reference,
    is dependent from existence of their composite parents.
    The deleting of all composite parents results the deleting of
    their composite dependent child objects (i.e. reference count is zero).
  
    \paragraph ex Example
    The following code:
  

  #include "oks/relationship.hpp"
   
  int main()
  {
  try
    {
      OksRelationship r(
        "consists of",                                   // name
        "Element",                                       // class type
        OksRelationship::Zero,                           // low cc in Zero
        OksRelationship::Many,                           // high cc is Many
        true,                                            // is composite
        true,                                            // is exclusive
        true,                                            // is dependent
        "A structure consists of zero or many elements"  // description
      );
   
      std::cout << r;
    }
  catch (const std::exception& ex)
    {
      std::cerr << "Caught exception:\n" << ex.what() << std::endl;
    }
  return 0;
  }

  produces:

  Relationship name: "consists of"
  class type: "Element"
  low cardinality constraint is zero
  high cardinality constraint is many
  is composite reference
  is exclusive reference
  is dependent reference
  has description: "A structure consists of zero or many elements"

Definition at line 99 of file relationship.hpp.

Member Enumeration Documentation

CardinalityConstraint

enum dunedaq::oks::OksRelationship::CardinalityConstraint

Valid cardinality constraint types

Enumerator
Zero
One
Many

Definition at line 111 of file relationship.hpp.

  {
    Zero,
    One,
    Many
  };

Constructor & Destructor Documentation

OksRelationship() [1/3]

dunedaq::oks::OksRelationship::OksRelationship	(	const std::string &	name,
		OksClass *	p = nullptr )

OKS relationship simple constructor.

Create new OKS relationship providing name.

The parameter is:

Parameters

name	name of the attribute
p	containing parent class

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 42 of file relationship.cpp.

  : 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() [2/3]

dunedaq::oks::OksRelationship::OksRelationship	(	const std::string &	name,
		const std::string &	type,
		CardinalityConstraint	low_cc,
		CardinalityConstraint	high_cc,
		bool	composite,
		bool	exclusive,
		bool	dependent,
		const std::string &	description,
		OksClass *	p = nullptr )

OKS relationship complete constructor.

Create new OKS relationship providing all properties.

The parameters are:

Parameters

name	name of the attribute (max 128 bytes, see #s_max_name_length variable)
type	class type of relationship (i.e. name of existing OKS class)
low_cc	lowest possible number of objects linked via this relationship ("zero" or "one")
high_cc	highest possible number of objects linked via this relationship ("one" or "many")
composite	if true, set strong dependency on children objects
exclusive	if true, guaranty unique reference on children objects via such relationship by any object
dependent	if true, existence of children objects depends on existence of parent
description	description of the method (max 2000 bytes, see #s_max_description_length variable)
p	containing parent class

Exceptions

oks::exception

is thrown in case of problems.

Definition at line 56 of file relationship.cpp.

  : 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");
}

OksRelationship() [3/3]

dunedaq::oks::OksRelationship::OksRelationship ( OksXmlInputStream & s, OksClass * parent )

private

To be used by OksClass only

Definition at line 147 of file relationship.cpp.

  : 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()));
  }
}

Member Function Documentation

card2str()

const char * dunedaq::oks::OksRelationship::card2str ( CardinalityConstraint cc )

staticnoexcept

Helper method to convert cardinality constraint to string

Definition at line 37 of file relationship.cpp.

{
  return (cc == Zero ? "zero" : cc == One ? "one" : "many");
}

get_class_type()

OksClass * dunedaq::oks::OksRelationship::get_class_type ( ) const

inlinenoexcept

Get relationship type (pointer on OKS class).

Definition at line 185 of file relationship.hpp.

{ return p_class_type; }

get_description()

const std::string & dunedaq::oks::OksRelationship::get_description ( ) const

inlinenoexcept

Return description of relationship

Definition at line 207 of file relationship.hpp.

{ return p_description; }

get_high_cardinality_constraint()

CardinalityConstraint dunedaq::oks::OksRelationship::get_high_cardinality_constraint ( ) const

inlinenoexcept

Get relationship high cardinality constraint.

See set_high_cardinality_constraint() for more information.

Returns

the relationship high cardinality constraint

Definition at line 251 of file relationship.hpp.

{ return p_high_cc; }

get_is_composite()

bool dunedaq::oks::OksRelationship::get_is_composite ( ) const

inlinenoexcept

Returns the true, if relationship is composite and false, if not.

Definition at line 269 of file relationship.hpp.

{ return p_composite; }

get_is_dependent()

bool dunedaq::oks::OksRelationship::get_is_dependent ( ) const

inlinenoexcept

Returns the true, if relationship is dependent and false, if not.

Definition at line 316 of file relationship.hpp.

{ return p_dependent; }

get_is_exclusive()

bool dunedaq::oks::OksRelationship::get_is_exclusive ( ) const

inlinenoexcept

Returns the true, if relationship is exclusive and false, if not.

Definition at line 299 of file relationship.hpp.

{ return p_exclusive; }

get_low_cardinality_constraint()

CardinalityConstraint dunedaq::oks::OksRelationship::get_low_cardinality_constraint ( ) const

inlinenoexcept

Get relationship low cardinality constraint.

See set_low_cardinality_constraint() for more information.

Returns

the relationship low cardinality constraint

Definition at line 227 of file relationship.hpp.

{ return p_low_cc; }

get_name()

const std::string & dunedaq::oks::OksRelationship::get_name ( ) const

inlinenoexcept

Methods to access relationship properties.

Definition at line 169 of file relationship.hpp.

{ return p_name; }

get_type()

const std::string & dunedaq::oks::OksRelationship::get_type ( ) const

inlinenoexcept

Get relationship type (string).

Definition at line 189 of file relationship.hpp.

{ return p_rclass; }

operator==()

bool dunedaq::oks::OksRelationship::operator==

(

const class OksRelationship &

r

)

const

Definition at line 82 of file relationship.cpp.

{
  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)));
}

save()

void dunedaq::oks::OksRelationship::save ( OksXmlOutputStream & s ) const

private

private constructor from XML stream

Definition at line 123 of file relationship.cpp.

{
  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();
}

set_description()

void dunedaq::oks::OksRelationship::set_description

(

const std::string &

description

)

Set relationship description.

Parameters

description

new description of relationship (max 2000 bytes, see #s_max_description_length variable)

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

Definition at line 283 of file relationship.cpp.

{
  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);
  }
}

set_high_cardinality_constraint()

void dunedaq::oks::OksRelationship::set_high_cardinality_constraint

(

CardinalityConstraint

h_cc

)

Set relationship high cardinality constraint.

The high cardinality constraint defiles highest possible number of objects linked via this relationship. It must be OksRelationship::One or OksRelationship::Many.

Parameters

cc	the high cardinality constraint

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

Definition at line 317 of file relationship.cpp.

{
  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);
    }
  }
}

set_is_composite()

void dunedaq::oks::OksRelationship::set_is_composite

(

bool

composite

)

Set the composite relationship property.

If relationship is composite, the parent object sets strong references on children objects and it is considered as composite or compound object.

The composite relationships are presented in a special way (as a diamond) by the OKS data editor graphical views, e.g. document is compound of sections:

============    1..N ===========
| Document |<>-------| Section |
============   has   ===========

Also, the oksdalgen package generates print() method of data access library in a different way depending on the composite relationship state:

• objects referenced via non-composite relationship are printed as references from parent object
• objects referenced via composite relationship are printed with details as part of parent object

Parameters

composite

pass true to make relationship composite

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

Definition at line 337 of file relationship.cpp.

{
  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);
  }
}

set_is_dependent()

void dunedaq::oks::OksRelationship::set_is_dependent

(

bool

dependent

)

Set the composite relationship dependent property.

If relationship is dependent, the child object will be removed when its parent object is removed and the child is not referenced by another parents via dependent composite relationships.

Parameters

dependent

pass true to make relationship dependent

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

Definition at line 365 of file relationship.cpp.

{
  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);
  }
}

set_is_exclusive()

void dunedaq::oks::OksRelationship::set_is_exclusive

(

bool

exclusive

)

Set the composite relationship exclusive property.

If relationship is exclusive, the child object can only be referenced by single parent via given relationship.

Parameters

exclusive

pass true to make relationship exclusive

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

Definition at line 351 of file relationship.cpp.

{
  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);
  }
}

set_low_cardinality_constraint()

void dunedaq::oks::OksRelationship::set_low_cardinality_constraint

(

CardinalityConstraint

cc

)

Set relationship low cardinality constraint.

The low cardinality constraint defiles lowest possible number of objects linked via this relationship. It must be OksRelationship::Zero or OksRelationship::One.

Parameters

cc	the low cardinality constraint

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

Definition at line 297 of file relationship.cpp.

{
  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);
    }
  }
}

set_name()

void dunedaq::oks::OksRelationship::set_name

(

const std::string &

new_name

)

Set relationship name.

Relationships linked with the same class shall have different names.

Parameters

name	new name of relationship (max 128 bytes, see #s_max_name_length variable)

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

Definition at line 211 of file relationship.cpp.

{
  // 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;
  }
}

set_type()

void dunedaq::oks::OksRelationship::set_type

(

const std::string &

type

)

Set relationship type.

The type is a name of existing OKS class. The value of relationship can point on objects of that class or any objects of classes derived from this one.

Parameters

type	new type of relationship

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

Definition at line 260 of file relationship.cpp.

{
  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());
  }
}

str2card()

OksRelationship::CardinalityConstraint dunedaq::oks::OksRelationship::str2card ( const char * s )

staticnoexcept

Helper method to convert valid string to cardinality constraint

Definition at line 31 of file relationship.cpp.

{
  return (oks::cmp_str3(s, "one") ? One : oks::cmp_str4(s, "zero") ? Zero : Many);
}

Friends And Related Symbol Documentation

OksClass

friend class OksClass

friend

Definition at line 102 of file relationship.hpp.

OksData

friend struct OksData

friend

Definition at line 103 of file relationship.hpp.

OksKernel

friend class OksKernel

friend

Definition at line 101 of file relationship.hpp.

OksObject

friend class OksObject

friend

Definition at line 104 of file relationship.hpp.

operator<<

std::ostream & operator<< ( std::ostream & s, const OksRelationship & r )

friend

Definition at line 90 of file relationship.cpp.

{
  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;
}

Member Data Documentation

class_type_xml_attr

const char dunedaq::oks::OksRelationship::class_type_xml_attr = "class-type"

staticprivate

Definition at line 367 of file relationship.hpp.

description_xml_attr

const char dunedaq::oks::OksRelationship::description_xml_attr = "description"

staticprivate

Definition at line 366 of file relationship.hpp.

high_cc_xml_attr

const char dunedaq::oks::OksRelationship::high_cc_xml_attr = "high-cc"

staticprivate

Definition at line 369 of file relationship.hpp.

is_composite_xml_attr

const char dunedaq::oks::OksRelationship::is_composite_xml_attr = "is-composite"

staticprivate

Definition at line 370 of file relationship.hpp.

is_dependent_xml_attr

const char dunedaq::oks::OksRelationship::is_dependent_xml_attr = "is-dependent"

staticprivate

Definition at line 372 of file relationship.hpp.

is_exclusive_xml_attr

const char dunedaq::oks::OksRelationship::is_exclusive_xml_attr = "is-exclusive"

staticprivate

Definition at line 371 of file relationship.hpp.

low_cc_xml_attr

const char dunedaq::oks::OksRelationship::low_cc_xml_attr = "low-cc"

staticprivate

Definition at line 368 of file relationship.hpp.

mv_implement_xml_attr

const char dunedaq::oks::OksRelationship::mv_implement_xml_attr[]

staticprivate

Definition at line 373 of file relationship.hpp.

name_xml_attr

const char dunedaq::oks::OksRelationship::name_xml_attr = "name"

staticprivate

Definition at line 365 of file relationship.hpp.

ordered_xml_attr

const char dunedaq::oks::OksRelationship::ordered_xml_attr = "ordered"

staticprivate

Definition at line 374 of file relationship.hpp.

p_class

OksClass* dunedaq::oks::OksRelationship::p_class

private

Definition at line 349 of file relationship.hpp.

p_class_type

OksClass* dunedaq::oks::OksRelationship::p_class_type

private

Definition at line 350 of file relationship.hpp.

p_composite

bool dunedaq::oks::OksRelationship::p_composite

private

Definition at line 345 of file relationship.hpp.

p_dependent

bool dunedaq::oks::OksRelationship::p_dependent

private

Definition at line 347 of file relationship.hpp.

p_description

std::string dunedaq::oks::OksRelationship::p_description

private

Definition at line 348 of file relationship.hpp.

p_exclusive

bool dunedaq::oks::OksRelationship::p_exclusive

private

Definition at line 346 of file relationship.hpp.

p_high_cc

CardinalityConstraint dunedaq::oks::OksRelationship::p_high_cc

private

Definition at line 344 of file relationship.hpp.

p_low_cc

CardinalityConstraint dunedaq::oks::OksRelationship::p_low_cc

private

Definition at line 343 of file relationship.hpp.

p_name

std::string dunedaq::oks::OksRelationship::p_name

private

Definition at line 341 of file relationship.hpp.

p_ordered

bool dunedaq::oks::OksRelationship::p_ordered

private

Definition at line 351 of file relationship.hpp.

p_rclass

std::string dunedaq::oks::OksRelationship::p_rclass

private

Definition at line 342 of file relationship.hpp.

relationship_xml_tag

const char dunedaq::oks::OksRelationship::relationship_xml_tag = "relationship"

staticprivate

private method to save in XML stream

Valid xml tags and attributes

Definition at line 364 of file relationship.hpp.

---

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

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