#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;
   - \b strong or \b 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 93 of file relationship.hpp.

Member Enumeration Documentation

◆ CardinalityConstraint

enum dunedaq::oks::OksRelationship::CardinalityConstraint

Valid cardinality constraint types

Enumerator
Zero
One
Many

Definition at line 107 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 46 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 60 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 141 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.

185{return p_class_type;}

◆ get_description()

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

inlinenoexcept

Return description of relationship

Definition at line 210 of file relationship.hpp.

210{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 258 of file relationship.hpp.

258{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 278 of file relationship.hpp.

278{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 329 of file relationship.hpp.

329{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 310 of file relationship.hpp.

310{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 232 of file relationship.hpp.

232{return p_low_cc;}

◆ get_name()

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

inlinenoexcept

Methods to access relationship properties.

Definition at line 167 of file relationship.hpp.

167{return p_name;}

◆ get_type()

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

inlinenoexcept

Get relationship type (string).

Definition at line 190 of file relationship.hpp.

190{return p_rclass;}

◆ operator==()

bool dunedaq::oks::OksRelationship::operator== ( const class OksRelationship & r ) const

Definition at line 80 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 116 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 279 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 309 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 327 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 351 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 339 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 291 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 201 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 257 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 27 of file relationship.cpp.

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

Definition at line 98 of file relationship.hpp.

◆ operator<<

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

friend

Definition at line 98 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;
}

private method to save in XML stream

Valid xml tags and attributes

Definition at line 385 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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ CardinalityConstraint

Constructor & Destructor Documentation

◆ OksRelationship() [1/3]

◆ OksRelationship() [2/3]

◆ OksRelationship() [3/3]

Member Function Documentation

◆ card2str()

◆ get_class_type()

◆ get_description()

◆ get_high_cardinality_constraint()

◆ get_is_composite()

◆ get_is_dependent()

◆ get_is_exclusive()

◆ get_low_cardinality_constraint()

◆ get_name()

◆ get_type()

◆ operator==()

◆ save()

◆ set_description()

◆ set_high_cardinality_constraint()

◆ set_is_composite()

◆ set_is_dependent()

◆ set_is_exclusive()

◆ set_low_cardinality_constraint()

◆ set_name()

◆ set_type()

◆ str2card()

Friends And Related Symbol Documentation

◆ OksClass

◆ OksData

◆ OksKernel

◆ OksObject

◆ operator<<

Member Data Documentation

◆ class_type_xml_attr

◆ description_xml_attr

◆ high_cc_xml_attr

◆ is_composite_xml_attr

◆ is_dependent_xml_attr

◆ is_exclusive_xml_attr

◆ low_cc_xml_attr

◆ mv_implement_xml_attr

◆ name_xml_attr

◆ ordered_xml_attr

◆ p_class

◆ p_class_type

◆ p_composite

◆ p_dependent

◆ p_description

◆ p_exclusive

◆ p_high_cc

◆ p_low_cc

◆ p_name

◆ p_ordered

◆ p_rclass

◆ relationship_xml_tag