A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance. More...

#include <agrum/PRM/elements/PRMClass.h>

Inheritance diagram for gum::prm::PRMClass< GUM_SCALAR >:

Collaboration diagram for gum::prm::PRMClass< GUM_SCALAR >:

Public Member Functions
Constructors & destructor.
	PRMClass (std::string_view name)
	Default constructor.
	PRMClass (std::string_view name, PRMClass< GUM_SCALAR > &super, bool delayInheritance=false)
	Constructor for building a subclass of super.
	PRMClass (std::string_view name, const Set< PRMInterface< GUM_SCALAR > * > &set, bool delayInheritance=false)
	Constructor for building a Class<GUM_SCALAR> implementing several each interface in set.
	PRMClass (std::string_view name, PRMClass< GUM_SCALAR > &super, const Set< PRMInterface< GUM_SCALAR > * > &set, bool delayInheritance=false)
	Constructor for building a subclass of super and implementing each interface in set.
	PRMClass (const PRMClass< GUM_SCALAR > &source)=delete
	Copy constructor.
	PRMClass (const PRMClass< GUM_SCALAR > &&source)=delete
	Move constructor.
PRMClass< GUM_SCALAR > &	operator= (const PRMClass< GUM_SCALAR > &source)=delete
	Copy operator. Don't use it.
PRMClass< GUM_SCALAR > &	operator= (const PRMClass< GUM_SCALAR > &&source)=delete
	Move operator. Don't use it.
	~PRMClass () override
	Destructor.
PRMObject::prm_type	obj_type () const override
	Implementation of pure virtual method of PRMObject.
Graphical operator
PRMClassElement< GUM_SCALAR > &	get (NodeId id) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId).
const PRMClassElement< GUM_SCALAR > &	get (NodeId id) const override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId).
PRMClassElement<GUM_SCALAR> getters and setters
bool	isOutputNode (const PRMClassElement< GUM_SCALAR > &elt) const override
	Returns true if elt is an output node.
bool	isCastDescendant (std::string_view safe_name) const
	Return true if the attribute named safe_name is a cast descendant.
PRMClassElement< GUM_SCALAR > &	get (std::string_view name) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(const std::string&).
const PRMClassElement< GUM_SCALAR > &	get (std::string_view name) const override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(const std::string&).
NodeId	add (PRMClassElement< GUM_SCALAR > *elt) override
	See gum::prm::add(PRMClassElement<GUM_SCALAR>*).
NodeId	overload (PRMClassElement< GUM_SCALAR > *elt) override
	See gum::prm::overload(PRMClassElement<GUM_SCALAR>*).
void	addArc (std::string_view tail, std::string_view head) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::addArc().
const Set< PRMAttribute< GUM_SCALAR > * > &	attributes () const
	Returns the set of PRMAttribute<GUM_SCALAR> of this Class<GUM_SCALAR>.
const Set< PRMParameter< GUM_SCALAR > * > &	parameters () const
	Returns the set of parameters of this Class<GUM_SCALAR>.
HashTable< std::string, const PRMParameter< GUM_SCALAR > * >	scope () const
	Returns all the parameters in the scope of this class.
const Set< PRMAggregate< GUM_SCALAR > * > &	aggregates () const
	Returns the set of PRMAggregate<GUM_SCALAR> of this Class<GUM_SCALAR>.
const Set< PRMReferenceSlot< GUM_SCALAR > * > &	referenceSlots () const
	Returns the set of PRMReferenceSlot<GUM_SCALAR> of this Class<GUM_SCALAR>.
const Set< PRMSlotChain< GUM_SCALAR > * > &	slotChains () const
	Returns the set of PRMSlotChain<GUM_SCALAR> of this Class<GUM_SCALAR>.
Inheritance methods
bool	isSubTypeOf (const PRMClassElementContainer< GUM_SCALAR > &cec) const override
	Test if this Class<GUM_SCALAR> is a subclass of cec.
const PRMClass< GUM_SCALAR > &	super () const
	Returns the super Class<GUM_SCALAR> of this Class<GUM_SCALAR>.
const Set< PRMInterface< GUM_SCALAR > * > &	implements () const
	Returns the Set of PRMInterface<GUM_SCALAR> implemented by this Class<GUM_SCALAR>.
const Set< PRMClass< GUM_SCALAR > * > &	extensions () const
	Returns the set of Class<GUM_SCALAR> which are direct sub-Class<GUM_SCALAR> of this Class<GUM_SCALAR>.
Getters & setters operators
PRMClassElement< GUM_SCALAR > &	operator[] (NodeId id) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId).
const PRMClassElement< GUM_SCALAR > &	operator[] (NodeId id) const override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId).
PRMClassElement< GUM_SCALAR > &	operator[] (std::string_view name) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](const std::string&).
const PRMClassElement< GUM_SCALAR > &	operator[] (std::string_view name) const override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](const std::string&).
For custom inheritance
void	inheritReferenceSlots ()
void	inheritParameters ()
void	inheritAttributes ()
void	inheritAggregates ()
void	inheritSlotChains ()
void	initializeInheritance ()
void	completeInheritance (std::string_view attr)
Getters on the gum::PRMClassElement<GUM_SCALAR>.
virtual bool	belongsTo (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if elt belongs to this PRMClassElementContainer.
virtual bool	exists (std::string_view name) const
	Returns true if a member with the given name exists in this PRMClassElementContainer or in the PRMClassElementContainer hierarchy.
virtual bool	isInputNode (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if the node is an input node.
virtual void	setInputNode (const PRMClassElement< GUM_SCALAR > &elt, bool b)
	Set the input flag value of id at b.
virtual void	setOutputNode (const PRMClassElement< GUM_SCALAR > &elt, bool b)
	Set the output flag value of id at b.
virtual bool	isInnerNode (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if the node is an inner node.
Graphical operator
virtual bool	exists (NodeId id) const
	Returns true if a member with the given id exists in this PRMClassElementContainer or in the PRMClassElementContainer hierarchy.
virtual const DAG &	containerDag () const
	Returns the gum::DAG of this PRMClassElementContainer.
Inheritance getters and setters
virtual bool	isSuperTypeOf (const PRMClassElementContainer< GUM_SCALAR > &cec) const
	Test if this PRMClassElementContainer is a super type of cec.
Getters & setters.
const std::string &	name () const
	Returns the name of this object.
void	name (std::string_view name)
	Change the name of the PRM Object.
Operators
bool	operator== (const PRMObject &obj) const
	To PRMObject are equal if they have the same name (which is unique).
bool	operator!= (const PRMObject &obj) const
	To PRMObject are equal if they have the same name (which is unique).

Protected Member Functions
const DAG &	dag_ () const override
	returns a constant reference over this interface's dag.
DAG &	dag_ () override
	Returns a non constant reference over this PRMInterface<GUM_SCALAR>'s DAG.
void	findAllSubtypes_ (Set< PRMClassElementContainer< GUM_SCALAR > * > &set) override
	Fills set with all the subtypes of this Class<GUM_SCALAR>.
void	updateDescendants_ (const PRMClassElement< GUM_SCALAR > &elt) override
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>(const PRMClassElement<GUM_SCALAR>&).
virtual std::pair< bool, bool > &	getIOFlag_ (const PRMClassElement< GUM_SCALAR > &elt)
	Returns the IO flags of a PRMClassElement<GUM_SCALAR>.
virtual const std::pair< bool, bool > &	getIOFlag_ (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns the IO flags of a PRMClassElement<GUM_SCALAR>.
virtual void	setIOFlag_ (const PRMClassElement< GUM_SCALAR > &elt, const std::pair< bool, bool > &flags)
	Defines the IO flags of a PRMClassElement<GUM_SCALAR>.
virtual void	copyIOFlags_ (const PRMClassElementContainer< GUM_SCALAR > &c)
	Copy the IO Flags of c in this PRMClassElementContainer.

Private Attributes
HashTable< std::string, std::pair< bool, bool > >	_IOFlags_
	input / output flags, useful when inheriting or copying.
Graphical model members
Proceed with the copy of c in this.
DAG	_dag_
	The dag representing dependencies between formal attributes and slots.
NodeProperty< PRMClassElement< GUM_SCALAR > * >	_nodeIdMap_
	Mapping between node's id and their name (being an attribute or a slot). Used for fast access to a member given it's node id.
Private members.
std::string	_name_

Friends
class	PRMInterface< GUM_SCALAR >

PRMClassElement<GUM_SCALAR> members
HashTable< std::string, PRMClassElement< GUM_SCALAR > * >	_nameMap_
	Mapping between a member's name and itself. Used for fast access to a member given it's name.
Set< PRMAttribute< GUM_SCALAR > * >	_attributes_
	The sequence of PRMAttribute<GUM_SCALAR>s.
Set< PRMReferenceSlot< GUM_SCALAR > * >	_referenceSlots_
	The sequence of PRMReferenceSlot<GUM_SCALAR>.
Set< PRMAggregate< GUM_SCALAR > * >	_aggregates_
	The sequence of aggregate.
Set< PRMSlotChain< GUM_SCALAR > * >	_slotChains_
	The set of gum::PRMSlotChain<GUM_SCALAR>s.
Set< PRMParameter< GUM_SCALAR > * >	_parameters_
	The Set of parameters in this Class<GUM_SCALAR>.
void	_addCastDescendants_ (PRMClassElement< GUM_SCALAR > *attr)
	Recursively adds cast descendant of attr in this Class<GUM_SCALAR>.
void	_addCastDescendants_ (PRMAttribute< GUM_SCALAR > start, PRMAttribute< GUM_SCALAR > end)
	Recursively adds cast descendant from start to end in this Class<GUM_SCALAR>.

Inheritance members
PRMClass< GUM_SCALAR > *	_superClass_
	The alternate PRMClassElementContainer<GUM_SCALAR> searched for elements defined in this. Note that this is first searched for gum::PRMClassElement<GUM_SCALAR>.
Set< PRMInterface< GUM_SCALAR > * > *	_implements_
	The Set of implemented interface of this.
Set< PRMClass< GUM_SCALAR > * >	_extensions_
	The set of Class<GUM_SCALAR> which are extension of this Class<GUM_SCALAR> (i.e. direct subtypes).
Bijection< const DiscreteVariable , const DiscreteVariable > *	_bijection_
	The bijection between variables in super and variables in this The bijection's firsts are attributes in this and its seconds are attributes in c.
HashFunc< PRMClassElementContainer< GUM_SCALAR > * >	_dummy_hashfunc_
	a dummy member used to fix a compilation issue in clang4
void	_inheritClass_ (const PRMClass< GUM_SCALAR > &c)
	Proceed with the copy when this inherits c.
void	_implementInterfaces_ (bool delayInheritance)
	Proceed with the implementation of interfaces.
void	_checkInterfaces_ (PRMClassElement< GUM_SCALAR > *elt)
	Check that a given element respects all the class interfaces.
void	_checkInterface_ (PRMClassElement< GUM_SCALAR > elt, PRMInterface< GUM_SCALAR > i)
	Check that a given element respects a specific interface.
void	_checkRefInterfaces_ (PRMReferenceSlot< GUM_SCALAR > *elt)
	Check that a given element respects all the class interfaces.
void	_checkRefInterface_ (PRMReferenceSlot< GUM_SCALAR > elt, PRMInterface< GUM_SCALAR > i)
	Check that a given element respects a specific interface.
void	_addIOInterfaceFlags_ (PRMClassElement< GUM_SCALAR > *elt)
	Check if elt is present in an implementation. If it is, its IO flags are updated.
void	_addExtension_ (PRMClass< GUM_SCALAR > *c)
	This method is called when a sub-Class<GUM_SCALAR> of this Class<GUM_SCALAR> is created.
bool	_checkOverloadLegality_ (const PRMClassElement< GUM_SCALAR > overloaded, const PRMClassElement< GUM_SCALAR > overloader)
	Return true of overloaded can be overload by overloader.
void	_overloadAttribute_ (PRMAttribute< GUM_SCALAR > overloader, PRMAttribute< GUM_SCALAR > overloaded)
	Overloads an attribute.
void	_overloadAggregate_ (PRMAggregate< GUM_SCALAR > overloader, PRMClassElement< GUM_SCALAR > overloaded)
	Overloads an aggregate.
void	_overloadReference_ (PRMReferenceSlot< GUM_SCALAR > overloader, PRMReferenceSlot< GUM_SCALAR > overloaded)
	Overloads a reference slot.
void	_overloadParameter_ (PRMParameter< GUM_SCALAR > overloader, PRMParameter< GUM_SCALAR > overloaded)
	Overloads a parameter.

Built-in types.
enum class	prm_type : char { ALL , CLASS , PRM_INTERFACE , CLASS_ELT , TYPE , SYSTEM , INSTANCE }
	Enumeration of the different types of objects handled by a PRM. More...
static std::string	LEFT_CAST ()
	Enumeration of the different types of objects handled by a PRM.
static std::string	RIGHT_CAST ()
	Enumeration of the different types of objects handled by a PRM.
static std::string	enum2str (prm_type type)
	Returns the string representation of a PRMObject.
static INLINE bool	isClass (const PRMObject &obj)
	Returns true if obj_ptr is of type Class.
static INLINE bool	isInterface (const PRMObject &obj)
	Returns true if obj_ptr is of type PRMInterface.
static INLINE bool	isInstance (const PRMObject &obj)
	Returns true if obj_ptr is of type PRMInstance.

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::prm::PRMClass< GUM_SCALAR >

A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance.

See also: PRMClassElement

Definition at line 77 of file PRMClass.h.

Member Enumeration Documentation

◆ prm_type

enum class gum::prm::PRMObject::prm_type : char

stronginherited

Enumeration of the different types of objects handled by a PRM.

The "all" type is used to tell that we want any kind of PRMType (useful with iterators for example). No PRMObject will ever have "all" as type.

Enumerator
ALL
CLASS
PRM_INTERFACE
CLASS_ELT
TYPE
SYSTEM
INSTANCE

Definition at line 90 of file PRMObject.h.

90: char { ALL, CLASS, PRM_INTERFACE, CLASS_ELT, TYPE, SYSTEM, INSTANCE };

Constructor & Destructor Documentation

◆ PRMClass() [1/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass ( std::string_view name )

explicit

Default constructor.

Parameters

name	The class name.

Definition at line 60 of file PRMClass_tpl.h.

                                                        :
        PRMClassElementContainer< GUM_SCALAR >(name), _superClass_(nullptr), _implements_(nullptr),
        _bijection_(nullptr) {
      GUM_CONSTRUCTOR(PRMClass);
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _bijection_, _implements_, _superClass_, and gum::prm::PRMObject::name().

Referenced by PRMClass(), PRMClass(), PRMClass(), PRMClass(), PRMClass(), PRMClass(), ~PRMClass(), _addExtension_(), _inheritClass_(), isSubTypeOf(), operator=(), operator=(), PRMInterface< GUM_SCALAR >, and super().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PRMClass() [2/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	std::string_view	name,
		PRMClass< GUM_SCALAR > &	super,
		bool	delayInheritance = false )

Constructor for building a subclass of super.

Parameters

name	The subclass name.
super	The super Class<GUM_SCALAR> of this.
delayInheritance	If true, inheritance will be delayed.

Definition at line 67 of file PRMClass_tpl.h.

                                                                               :
        PRMClassElementContainer< GUM_SCALAR >(name), _superClass_(&super), _implements_(nullptr),
        _bijection_(new Bijection< const DiscreteVariable*, const DiscreteVariable* >()) {
      GUM_CONSTRUCTOR(PRMClass);
      if (!delayInheritance) {
        _dag_ = super.containerDag();
        _inheritClass_(super);
      }
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _bijection_, _dag_, _implements_, _inheritClass_(), _superClass_, gum::prm::PRMObject::name(), and super().

Here is the call graph for this function:

◆ PRMClass() [3/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	std::string_view	name,
		const Set< PRMInterface< GUM_SCALAR > * > &	set,
		bool	delayInheritance = false )

Constructor for building a Class<GUM_SCALAR> implementing several each interface in set.

Parameters

name	The sub class name.
set	The Set of implemented interfaces.
delayInheritance	If true, inheritance will be delayed.

Definition at line 80 of file PRMClass_tpl.h.

                                                                                                 :
        PRMClassElementContainer< GUM_SCALAR >(name), _superClass_(nullptr),
        _implements_(new Set< PRMInterface< GUM_SCALAR >* >(set)), _bijection_(nullptr) {
      GUM_CONSTRUCTOR(PRMClass);
 
      if (!delayInheritance) { _implementInterfaces_(false); }
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _bijection_, _implementInterfaces_(), _implements_, _superClass_, gum::prm::PRMObject::name(), and PRMInterface< GUM_SCALAR >.

Here is the call graph for this function:

◆ PRMClass() [4/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	std::string_view	name,
		PRMClass< GUM_SCALAR > &	super,
		const Set< PRMInterface< GUM_SCALAR > * > &	set,
		bool	delayInheritance = false )

Constructor for building a subclass of super and implementing each interface in set.

Parameters

name	The sub class name.
super	The super Class<GUM_SCALAR> of this.
set	The Set of implemented interfaces.
delayInheritance	If true, inheritance will be delayed.

Definition at line 91 of file PRMClass_tpl.h.

                                                                                                 :
        PRMClassElementContainer< GUM_SCALAR >(name), _superClass_(&super), _implements_(nullptr),
        _bijection_(new Bijection< const DiscreteVariable*, const DiscreteVariable* >()) {
      GUM_CONSTRUCTOR(PRMClass);
      if (!delayInheritance) {
        _dag_ = super.containerDag();
        _inheritClass_(super);
      }
 
      // Adding other implementation
      if (_implements_ == nullptr) {   // super has not created  _implements_
        _implements_ = new Set< PRMInterface< GUM_SCALAR >* >(set);
      } else {                         // we just add the new implementations
        for (const auto elt: set) {
          _implements_->insert(elt);
        }
      }
 
      if (!delayInheritance) { _implementInterfaces_(false); }
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _bijection_, _dag_, _implementInterfaces_(), _implements_, _inheritClass_(), _superClass_, gum::prm::PRMObject::name(), PRMInterface< GUM_SCALAR >, and super().

Here is the call graph for this function:

◆ PRMClass() [5/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass ( const PRMClass< GUM_SCALAR > & source )

delete

Copy constructor.

References PRMClass().

Here is the call graph for this function:

◆ PRMClass() [6/6]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass ( const PRMClass< GUM_SCALAR > && source )

delete

Move constructor.

References PRMClass().

Here is the call graph for this function:

◆ ~PRMClass()

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::~PRMClass ( )

override

Destructor.

Definition at line 133 of file PRMClass_tpl.h.

                                      {
      GUM_DESTRUCTOR(PRMClass);
 
      for (const auto& elt: _nodeIdMap_) {
        delete elt.second;
      }
 
      if (_implements_) { delete _implements_; }
 
      if (_bijection_) { delete _bijection_; }
    }

References PRMClass(), _bijection_, _implements_, and _nodeIdMap_.

Here is the call graph for this function:

Member Function Documentation

◆ _addCastDescendants_() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_addCastDescendants_	(	PRMAttribute< GUM_SCALAR > *	start,
		PRMAttribute< GUM_SCALAR > *	end )

private

Recursively adds cast descendant from start to end in this Class<GUM_SCALAR>.

Definition at line 907 of file PRMClass_tpl.h.

                                                                                       {
      PRMAttribute< GUM_SCALAR >* parent = start;
      PRMAttribute< GUM_SCALAR >* child  = 0;
 
      while (parent->type().superType() != end->type()) {
        child = parent->getCastDescendant();
        child->setId(nextNodeId());
        _nodeIdMap_.insert(child->id(), child);
        _dag_.addNodeWithId(child->id());
        // Only use child's safe name when adding to the name map!
        _nameMap_.insert(child->safeName(), child);
        _attributes_.insert(child);
        _addIOInterfaceFlags_(child);
        // Do not use Class<GUM_SCALAR>::insertArc(), child's CPF is already
        // initialized properly
        _dag_.addArc(parent->id(), child->id());
        parent = child;
      }
 
      parent->setAsCastDescendant(end);
      _dag_.addArc(parent->id(), end->id());
    }

References _addIOInterfaceFlags_(), _attributes_, _dag_, _nameMap_, _nodeIdMap_, gum::prm::PRMAttribute< GUM_SCALAR >::getCastDescendant(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::nextNodeId(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAttribute< GUM_SCALAR >::setAsCastDescendant(), gum::prm::PRMClassElement< GUM_SCALAR >::setId(), gum::prm::PRMType::superType(), and gum::prm::PRMAttribute< GUM_SCALAR >::type().

Here is the call graph for this function:

◆ _addCastDescendants_() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_addCastDescendants_ ( PRMClassElement< GUM_SCALAR > * attr )

private

Recursively adds cast descendant of attr in this Class<GUM_SCALAR>.

Definition at line 678 of file PRMClass_tpl.h.

                                                                                         {
      auto                        parent = attr;
      PRMAttribute< GUM_SCALAR >* child  = 0;
 
      while (parent->type().isSubType()) {
        child = parent->getCastDescendant();
 
        // Check if id was reserved by one of the class interfaces
        bool found = false;
        if (_implements_ != nullptr) {
          for (auto i: implements()) {
            if (i->exists(child->safeName())) {
              child->setId(i->get(child->safeName()).id());
              found = true;
              break;
            }
          }
        }
        if (!found) {
          child->setId(nextNodeId());
          _dag_.addNodeWithId(child->id());
        }
        _nodeIdMap_.insert(child->id(), child);
        // Only use child's safe name when adding to the name map!
        _nameMap_.insert(child->safeName(), child);
        _attributes_.insert(child);
        // Do not use Class<GUM_SCALAR>::insertArc(), child's CPF is already
        // initialized properly
        _dag_.addArc(parent->id(), child->id());
 
        parent = child;
      }
    }

References _attributes_, _dag_, _implements_, _nameMap_, _nodeIdMap_, gum::prm::PRMAttribute< GUM_SCALAR >::getCastDescendant(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), implements(), gum::prm::nextNodeId(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), and gum::prm::PRMClassElement< GUM_SCALAR >::setId().

Referenced by _overloadAttribute_(), and add().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _addExtension_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_addExtension_ ( PRMClass< GUM_SCALAR > * c )

private

This method is called when a sub-Class<GUM_SCALAR> of this Class<GUM_SCALAR> is created.

Parameters

c	The Class<GUM_SCALAR> added as a direct sub-Class<GUM_SCALAR> of this.

Exceptions

DuplicateElement Raised if c is already a sub-Class<GUM_SCALAR> of this.

Definition at line 1186 of file PRMClass_tpl.h.

                                                                         {
      _extensions_.insert(c);
    }

References PRMClass(), and _extensions_.

Here is the call graph for this function:

◆ _addIOInterfaceFlags_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_addIOInterfaceFlags_ ( PRMClassElement< GUM_SCALAR > * elt )

private

Check if elt is present in an implementation. If it is, its IO flags are updated.

Definition at line 941 of file PRMClass_tpl.h.

                                                                                         {
      // We only add IO Flags if elt matches is required by and interface
      if (_implements_ != nullptr) {
        for (const auto impl: *_implements_) {
          PRMInterface< GUM_SCALAR >* super = impl;
          while (super) {
            // If the attribute is defined in an interface, we set it as an
            // OutputNode
            if (impl->exists(elt->name())) {
              try {
                this->getIOFlag_(*elt).second = true;
              } catch (NotFound const&) { this->setIOFlag_(*elt, std::make_pair(false, true)); }
            }
            super = super->_superInterface_ ? &(super->super()) : nullptr;
          }
        }
      }
    }

References _implements_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::getIOFlag_(), gum::prm::PRMObject::name(), PRMInterface< GUM_SCALAR >, gum::prm::PRMClassElementContainer< GUM_SCALAR >::setIOFlag_(), and super().

Referenced by _addCastDescendants_(), add(), and overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkInterface_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_checkInterface_	(	PRMClassElement< GUM_SCALAR > *	elt,
		PRMInterface< GUM_SCALAR > *	i )

private

Check that a given element respects a specific interface.

Definition at line 532 of file PRMClass_tpl.h.

                                                                                    {
      const auto& i_elt   = i->get(elt->name());
      bool        is_attr = PRMClassElement< GUM_SCALAR >::isAttribute(i_elt);
      bool        is_agg  = PRMClassElement< GUM_SCALAR >::isAggregate(i_elt);
 
      if (!(is_attr || is_agg)) {
        GUM_ERROR(OperationNotAllowed, "Class does not respect it's interface")
      }
 
      if (!elt->type().isSubTypeOf(i_elt.type())) {
        GUM_ERROR(OperationNotAllowed, "Attribute type does not respect class interface")
      }
 
      if (elt->type() != i_elt.type()) {
        if (!this->exists(i_elt.safeName())) {
          GUM_ERROR(OperationNotAllowed, "Attribute type does not respect class interface")
        }
        elt = &(this->get(i_elt.safeName()));
      }
 
      // Node must be reserved by constructor
      if (!_dag_.existsNode(i_elt.id())) {
        GUM_ERROR(FatalError, "Class does not reserved implemented nodes")
      }
 
      // Removing unused node and changing to proper node
      if (elt->id() != i_elt.id()) {
        // Update cast descendants
        for (auto child: _dag_.children(elt->id())) {
          _dag_.addArc(i_elt.id(), child);
        }
        _dag_.eraseNode(elt->id());
      }
      _nodeIdMap_.erase(elt->id());
      elt->setId(i_elt.id());
      _nodeIdMap_.insert(elt->id(), elt);
    }

References _dag_, _nodeIdMap_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), get(), gum::prm::PRMInterface< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMType::isSubTypeOf(), gum::prm::PRMObject::name(), PRMInterface< GUM_SCALAR >, gum::prm::PRMClassElement< GUM_SCALAR >::setId(), and gum::prm::PRMClassElement< GUM_SCALAR >::type().

Referenced by _checkInterfaces_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkInterfaces_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_checkInterfaces_ ( PRMClassElement< GUM_SCALAR > * elt )

private

Check that a given element respects all the class interfaces.

Definition at line 523 of file PRMClass_tpl.h.

                                                                                     {
      if (_implements_ != nullptr) {
        for (auto i: implements()) {
          if (i->exists(elt->name())) { _checkInterface_(elt, i); }
        }
      }
    }

References _checkInterface_(), _implements_, implements(), and gum::prm::PRMObject::name().

Referenced by add().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkOverloadLegality_()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClass< GUM_SCALAR >::_checkOverloadLegality_	(	const PRMClassElement< GUM_SCALAR > *	overloaded,
		const PRMClassElement< GUM_SCALAR > *	overloader )

private

Return true of overloaded can be overload by overloader.

Definition at line 1143 of file PRMClass_tpl.h.

                                                         {
      if (overloaded->elt_type() != overloader->elt_type()) { return false; }
 
      switch (overloaded->elt_type()) {
        case PRMClassElement< GUM_SCALAR >::prm_attribute : {
          if (!overloader->type().isSubTypeOf(overloaded->type())) { return false; }
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_refslot : {
          const auto& new_slot_type
              = static_cast< const PRMReferenceSlot< GUM_SCALAR >* >(overloader)->slotType();
          const auto& old_slot_type
              = static_cast< const PRMReferenceSlot< GUM_SCALAR >* >(overloaded)->slotType();
 
          if (!new_slot_type.isSubTypeOf(old_slot_type)) { return false; }
 
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_parameter : {
          auto overloaded_param = static_cast< const PRMParameter< GUM_SCALAR >* >(overloaded);
          auto overloader_param = static_cast< const PRMParameter< GUM_SCALAR >* >(overloader);
 
          return overloaded_param->valueType() == overloader_param->valueType();
          break;
        }
 
        default : {
          return false;
        }
      }
      return true;
    }

References gum::prm::PRMClassElement< GUM_SCALAR >::elt_type(), gum::prm::PRMType::isSubTypeOf(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::prm::PRMClassElement< GUM_SCALAR >::prm_parameter, gum::prm::PRMClassElement< GUM_SCALAR >::prm_refslot, gum::prm::PRMClassElement< GUM_SCALAR >::type(), and gum::prm::PRMParameter< GUM_SCALAR >::valueType().

Referenced by overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkRefInterface_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_checkRefInterface_	(	PRMReferenceSlot< GUM_SCALAR > *	elt,
		PRMInterface< GUM_SCALAR > *	i )

private

Check that a given element respects a specific interface.

Definition at line 581 of file PRMClass_tpl.h.

                                                                                        {
      auto& i_elt = i->get(ref->name());
      if (i_elt.elt_type() != ref->elt_type()) {
        GUM_ERROR(OperationNotAllowed, "Class does not respect it's interface")
      }
      auto& i_ref = static_cast< PRMReferenceSlot< GUM_SCALAR >& >(i_elt);
      if (!ref->slotType().isSubTypeOf(i_ref.slotType())) {
        GUM_ERROR(OperationNotAllowed, "ReferenceSlot type does not respect class interface")
      }
      // Node must be reserved by constructor
      if (!_dag_.exists(i_ref.id())) {
        GUM_ERROR(FatalError,
                  "class " << this->name() << " does not respect interface " << i->name()
                           << " implementation");
      }
      // Removing unused node and changin to propoer node
      if (ref->id() != i_ref.id()) { _dag_.eraseNode(ref->id()); }
      _nodeIdMap_.erase(ref->id());
      ref->setId(i_ref.id());
      _nodeIdMap_.insert(ref->id(), ref);
    }

References _dag_, _nodeIdMap_, gum::prm::PRMReferenceSlot< GUM_SCALAR >::elt_type(), gum::prm::PRMInterface< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::name(), PRMInterface< GUM_SCALAR >, gum::prm::PRMClassElement< GUM_SCALAR >::setId(), and gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType().

Referenced by _checkRefInterfaces_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkRefInterfaces_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_checkRefInterfaces_ ( PRMReferenceSlot< GUM_SCALAR > * elt )

private

Check that a given element respects all the class interfaces.

Definition at line 572 of file PRMClass_tpl.h.

                                                                                         {
      if (_implements_ != nullptr) {
        for (auto i: implements()) {
          if (i->exists(ref->name())) { _checkRefInterface_(ref, i); }
        }
      }
    }

References _checkRefInterface_(), _implements_, implements(), and gum::prm::PRMObject::name().

Referenced by add().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _implementInterfaces_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_implementInterfaces_ ( bool delayInheritance )

private

Proceed with the implementation of interfaces.

Definition at line 116 of file PRMClass_tpl.h.

                                                                              {
      for (const auto impl: *_implements_) {
        impl->_addImplementation_(this);
        if ((!_superClass_) || (!super().isSubTypeOf(*impl)) || delayedInheritance) {
          // Reserve reference id in DAG
          for (auto ref: impl->referenceSlots()) {
            _dag_.addNodeWithId(ref->id());
          }
          // Reserve attribute id in DAG
          for (auto attr: impl->attributes()) {
            _dag_.addNodeWithId(attr->id());
          }
        }
      }
    }

References _dag_, _implements_, _superClass_, isSubTypeOf(), and super().

Referenced by PRMClass(), PRMClass(), and initializeInheritance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _inheritClass_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_inheritClass_ ( const PRMClass< GUM_SCALAR > & c )

private

Proceed with the copy when this inherits c.

Definition at line 317 of file PRMClass_tpl.h.

                                                                               {
      if (_superClass_) {
        _superClass_->_addExtension_(this);
        // Adding implemented interfaces of c, if any
        if (c._implements_) {
          if (!_implements_) {
            _implements_ = new Set< PRMInterface< GUM_SCALAR >* >(*(c._implements_));
          } else {
            for (auto i: *(c._implements_)) {
              _implements_->insert(i);
            }
          }
        }
 
        // Copying attributes, the bijection's firsts are attributes in this and
        // its
        // seconds are attributes
        // in c.
        Bijection< const DiscreteVariable*, const DiscreteVariable* > bij;
 
        // Copying parameters
        for (const auto c_param: c._parameters_) {
          auto param = new PRMParameter< GUM_SCALAR >(c_param->name(),
                                                      c_param->valueType(),
                                                      c_param->value());
 
          _parameters_.insert(param);
 
          param->setId(c_param->id());
          _nodeIdMap_.insert(param->id(), param);
          _nameMap_.insert(param->name(), param);
        }
 
        // Copying attributes
        for (const auto c_attr: c._attributes_) {
          // using multiDimSparse to prevent unecessary memory allocation for
          // large arrays (the tensors are copied latter)
          auto attr = c_attr->newFactory(*this);
 
          bij.insert(&(c_attr->type().variable()), &(attr->type().variable()));
          attr->setId(c_attr->id());
          _nodeIdMap_.insert(attr->id(), attr);
          _attributes_.insert(attr);
 
          if (c._nameMap_[c_attr->name()] == c._nameMap_[c_attr->safeName()]) {
            _nameMap_.insert(attr->name(), attr);
          }
 
          _nameMap_.insert(attr->safeName(), attr);
        }
 
        // Copying aggregates
        for (const auto c_agg: c._aggregates_) {
          PRMAggregate< GUM_SCALAR >* agg = nullptr;
 
          try {
            agg = new PRMAggregate< GUM_SCALAR >(c_agg->name(),
                                                 c_agg->agg_type(),
                                                 c_agg->type(),
                                                 c_agg->label());
          } catch (OperationNotAllowed const&) {
            agg = new PRMAggregate< GUM_SCALAR >(c_agg->name(), c_agg->agg_type(), c_agg->type());
          }
 
          bij.insert(&(c_agg->type().variable()), &(agg->type().variable()));
          agg->setId(c_agg->id());
          _nodeIdMap_.insert(agg->id(), agg);
          _aggregates_.insert(agg);
 
          if (c._nameMap_[c_agg->name()] == c._nameMap_[c_agg->safeName()])
            _nameMap_.insert(agg->name(), agg);
 
          _nameMap_.insert(agg->safeName(), agg);
        }
 
        // Copying reference slots
        for (const auto c_refslot: c._referenceSlots_) {
          PRMReferenceSlot< GUM_SCALAR >* ref = new PRMReferenceSlot< GUM_SCALAR >(
              c_refslot->name(),
              const_cast< PRMClassElementContainer< GUM_SCALAR >& >(c_refslot->slotType()),
              c_refslot->isArray());
 
          ref->setId(c_refslot->id());
          _nodeIdMap_.insert(ref->id(), ref);
          _referenceSlots_.insert(ref);
 
          if (c._nameMap_[c_refslot->name()] == c._nameMap_[c_refslot->safeName()])
            _nameMap_.insert(ref->name(), ref);
 
          _nameMap_.insert(ref->safeName(), ref);
        }
 
        // Copying slot chains
        for (const auto c_slotchain: c._slotChains_) {
          // We just need to change the first PRMReferenceSlot<GUM_SCALAR> in
          // the
          // chain
          Sequence< PRMClassElement< GUM_SCALAR >* > chain(c_slotchain->chain());
 
          chain.setAtPos(0, _nameMap_[c_slotchain->chain().front()->name()]);
 
          PRMSlotChain< GUM_SCALAR >* sc
              = new PRMSlotChain< GUM_SCALAR >(c_slotchain->name(), chain);
          bij.insert(&(c_slotchain->type().variable()), &(sc->type().variable()));
          sc->setId(c_slotchain->id());
          _nodeIdMap_.insert(sc->id(), sc);
          _slotChains_.insert(sc);
 
          _nameMap_.insert(sc->name(), sc);
          _nameMap_.insert(sc->safeName(), sc);
        }
 
        // Copying dependencies yield by arcs
        for (const auto& arc: c.containerDag().arcs()) {
          _nodeIdMap_[arc.tail()]->addChild(*(_nodeIdMap_[arc.head()]));
          _nodeIdMap_[arc.head()]->addParent(*(_nodeIdMap_[arc.tail()]));
        }
 
        // Copying the IO flag
        this->copyIOFlags_(c);
        // Copying content of CPF
        for (const auto attr: c._attributes_) {
          auto a = static_cast< PRMAttribute< GUM_SCALAR >* >(_nameMap_[attr->safeName()]);
          a->copyCpf(bij, *attr);
        }
      }
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _aggregates_, _attributes_, _implements_, _nameMap_, _nodeIdMap_, _parameters_, _referenceSlots_, _slotChains_, _superClass_, gum::ArcGraphPart::arcs(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::copyIOFlags_(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::BijectionImplementation< T1, T2, Gen >::insert(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::SequenceImplementation< Key, Gen >::setAtPos(), gum::prm::PRMClassElement< GUM_SCALAR >::setId(), gum::prm::PRMAggregate< GUM_SCALAR >::type(), gum::prm::PRMSlotChain< GUM_SCALAR >::type(), and gum::prm::PRMType::variable().

Referenced by PRMClass(), and PRMClass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _overloadAggregate_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_overloadAggregate_	(	PRMAggregate< GUM_SCALAR > *	overloader,
		PRMClassElement< GUM_SCALAR > *	overloaded )

private

Overloads an aggregate.

Definition at line 1136 of file PRMClass_tpl.h.

                                                                                                {
      _nameMap_.insert(overloader->safeName(), overloader);
      _aggregates_.insert(overloader);
    }

References _aggregates_, _nameMap_, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _overloadAttribute_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_overloadAttribute_	(	PRMAttribute< GUM_SCALAR > *	overloader,
		PRMAttribute< GUM_SCALAR > *	overloaded )

private

Overloads an attribute.

Definition at line 774 of file PRMClass_tpl.h.

                                                                                             {
      _dag_.eraseParents(overloaded->id());
 
      // Checking if we have to add cast descendant
      if (overloader->type() != overloaded->type()) {
        overloader->setId(nextNodeId());
        _dag_.addNodeWithId(overloader->id());
        _nodeIdMap_.insert(overloader->id(), overloader);
        _nameMap_[overloader->name()] = overloader;
        _nameMap_.insert(overloader->safeName(), overloader);
        _attributes_.insert(overloader);
        _addCastDescendants_(overloader, overloaded);
      } else {
        overloader->setId(overloaded->id());
        _nodeIdMap_[overloader->id()]     = overloader;
        _nameMap_[overloader->name()]     = overloader;
        _nameMap_[overloader->safeName()] = overloader;
        _attributes_.erase(overloaded);
        _attributes_.insert(overloader);
        overloader->overload(overloaded);
        delete overloaded;
      }
    }

References _addCastDescendants_(), _attributes_, _dag_, _nameMap_, _nodeIdMap_, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::name(), gum::prm::nextNodeId(), gum::prm::PRMAttribute< GUM_SCALAR >::overload(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMClassElement< GUM_SCALAR >::setId(), and gum::prm::PRMAttribute< GUM_SCALAR >::type().

Referenced by overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _overloadParameter_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_overloadParameter_	(	PRMParameter< GUM_SCALAR > *	overloader,
		PRMParameter< GUM_SCALAR > *	overloaded )

private

Overloads a parameter.

Definition at line 895 of file PRMClass_tpl.h.

                                                                                             {
      overloader->setId(overloaded->id());
      _nodeIdMap_[overloader->id()]     = overloader;
      _nameMap_[overloader->name()]     = overloader;
      _nameMap_[overloader->safeName()] = overloader;
      _parameters_.erase(overloaded);
      _parameters_.insert(overloader);
      delete overloaded;
    }

References _nameMap_, _nodeIdMap_, _parameters_, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), and gum::prm::PRMClassElement< GUM_SCALAR >::setId().

Referenced by overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _overloadReference_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::_overloadReference_	(	PRMReferenceSlot< GUM_SCALAR > *	overloader,
		PRMReferenceSlot< GUM_SCALAR > *	overloaded )

private

Overloads a reference slot.

Definition at line 800 of file PRMClass_tpl.h.

                                                                                                 {
      // Adding overloading reference
      overloader->setId(overloaded->id());
      _nodeIdMap_[overloader->id()] = overloader;
      _nameMap_[overloader->name()] = overloader;
      _nameMap_.insert(overloader->safeName(), overloader);
      _referenceSlots_.insert(overloader);
      PRMSlotChain< GUM_SCALAR >*                sc   = 0;
      PRMReferenceSlot< GUM_SCALAR >*            ref  = 0;
      PRMClassElement< GUM_SCALAR >*             next = 0;
      std::vector< PRMSlotChain< GUM_SCALAR >* > toRemove, toAdd;
 
      // Updating PRMSlotChain<GUM_SCALAR> which started with overloaded
      for (const auto slotchain: _slotChains_) {
        // If the attribute pointed by this slotchain is overloaded, we need to
        // change the slotchain
        // names to it's safename version: ref.attr is replaced by
        // ref.(type)attr.
        if ((slotchain->chain().atPos(0) == overloaded)) {
          Sequence< PRMClassElement< GUM_SCALAR >* > seq;
          seq.insert(overloader);
 
          auto elt = ++(slotchain->chain().begin());
 
          while (elt != slotchain->chain().end()) {
            ref  = static_cast< PRMReferenceSlot< GUM_SCALAR >* >(seq.back());
            next = &(ref->slotType().get((*elt)->name()));
            seq.insert(next);
            ++elt;
          }
 
          // If the slotchain last element type changes, we change the slotchain
          // to
          // point towards the cast decendant
          // with the correct type
          if (seq.back()->type() != slotchain->lastElt().type()) {
            seq.erase(seq.back());
            seq.insert(&(static_cast< PRMReferenceSlot< GUM_SCALAR >* >(seq.back())
                             ->slotType()
                             .get(slotchain->lastElt().safeName())));
            std::string sc_name;
            std::string dot = ".";
 
            for (Size i = 0; i < seq.size() - 1; ++i) {
              sc_name += seq.atPos(i)->name() + dot;
            }
 
            sc_name += seq.back()->safeName();
            sc = new PRMSlotChain< GUM_SCALAR >(sc_name, seq);
            sc->setId(slotchain->id());
 
            for (const auto child: this->containerDag().children(sc->id())) {
              auto& elt = get(child);
              if (PRMClassElement< GUM_SCALAR >::isAttribute(elt)) {
                auto& attr     = static_cast< PRMAttribute< GUM_SCALAR >& >(elt);
                auto& old_type = slotchain->lastElt().type();
                auto& new_type = sc->lastElt().type();
                attr.swap(old_type, new_type);
              } else {
                GUM_ERROR(OperationNotAllowed, "unexpected ClassElement")
                // get( child ).cpf().replace(
                // slotchain->lastElt().type().variable(),
                // sc->lastElt().type().variable() );
              }
            }
 
            toAdd.push_back(sc);
            toRemove.push_back(slotchain);
          } else {
            // Types are identical, we just need to change the first reference
            slotchain->chain().setAtPos(0, overloader);
          }
        }
      }
 
      for (const auto torem: toRemove) {
        _nameMap_.erase(torem->name());
        _slotChains_.erase(torem);
        delete torem;
      }
 
      for (const auto toadd: toAdd) {
        _nameMap_.insert(toadd->name(), toadd);
        _nodeIdMap_[toadd->id()] = toadd;
        _slotChains_.insert(sc);
      }
 
      // Removing overloaded PRMReferenceSlot<GUM_SCALAR>
      _referenceSlots_.erase(overloaded);
      _nameMap_.erase(overloaded->safeName());
      delete overloaded;
    }

References _nameMap_, _nodeIdMap_, _referenceSlots_, _slotChains_, gum::SequenceImplementation< Key, Gen >::atPos(), gum::SequenceImplementation< Key, Gen >::back(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::SequenceImplementation< Key, Gen >::erase(), get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::SequenceImplementation< Key, Gen >::insert(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMSlotChain< GUM_SCALAR >::lastElt(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMClassElement< GUM_SCALAR >::setId(), gum::SequenceImplementation< Key, Gen >::size(), gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType(), and gum::prm::PRMAttribute< GUM_SCALAR >::type().

Referenced by overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add()

template<GUM_Numeric GUM_SCALAR>

NodeId gum::prm::PRMClass< GUM_SCALAR >::add ( PRMClassElement< GUM_SCALAR > * elt )

overridevirtual

See gum::prm::add(PRMClassElement<GUM_SCALAR>*).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 605 of file PRMClass_tpl.h.

                                                                         {
      if (_nameMap_.exists(elt->name())) {
        GUM_ERROR(DuplicateElement,
                  "name " << elt->name() << " already used by another ClassElement");
      }
 
      elt->setId(nextNodeId());
      _dag_.addNodeWithId(elt->id());
      _nodeIdMap_.insert(elt->id(), elt);
      _nameMap_.insert(elt->name(), elt);
 
      try {
        _nameMap_.insert(elt->safeName(), elt);
      } catch (DuplicateElement& e) {
        if (!(PRMClassElement< GUM_SCALAR >::isSlotChain(*elt)
              || PRMClassElement< GUM_SCALAR >::isParameter(*elt))) {
          throw DuplicateElement(e);
        }
      }
 
      switch (elt->elt_type()) {
        case PRMClassElement< GUM_SCALAR >::prm_attribute : {
          _attributes_.insert(static_cast< PRMAttribute< GUM_SCALAR >* >(elt));
          _addCastDescendants_(static_cast< PRMAttribute< GUM_SCALAR >* >(elt));
 
          // Update attribute or cast descendant id to respect implemented
          // interface
          _checkInterfaces_(elt);
 
          _addIOInterfaceFlags_(elt);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_aggregate : {
          _aggregates_.insert(static_cast< PRMAggregate< GUM_SCALAR >* >(elt));
          _addCastDescendants_(static_cast< PRMAttribute< GUM_SCALAR >* >(elt));
 
          // Update attribute or cast descendant id to respect implemented
          // interface
          _checkInterfaces_(elt);
 
          _addIOInterfaceFlags_(elt);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_refslot : {
          auto ref = static_cast< PRMReferenceSlot< GUM_SCALAR >* >(elt);
          _referenceSlots_.insert(ref);
 
          // Updating ref's id if ref implements an interface
          _checkRefInterfaces_(ref);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_slotchain : {
          _slotChains_.insert(static_cast< PRMSlotChain< GUM_SCALAR >* >(elt));
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_parameter : {
          _parameters_.insert(static_cast< PRMParameter< GUM_SCALAR >* >(elt));
          break;
        }
 
        default : {
          GUM_ERROR(FatalError, "unknown ClassElement<GUM_SCALAR> type")
        }
      }
 
      return elt->id();
    }

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInputs_(), gum::prm::PRMFactory< GUM_SCALAR >::addAggregator(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound(), and gum::prm::PRMFactory< GUM_SCALAR >::startAggregator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addArc()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::addArc	(	std::string_view	tail,
		std::string_view	head )

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::addArc().

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 482 of file PRMClass_tpl.h.

                                                                                          {
      auto p_tail = _nameMap_.tryGet(tail_name);
      auto p_head = _nameMap_.tryGet(head_name);
 
      if (!p_tail || !p_head) {
        GUM_ERROR(NotFound, "tail and/or head of arc does not exists in this Class")
      }
      PRMClassElement< GUM_SCALAR >* tail = *p_tail;
      PRMClassElement< GUM_SCALAR >* head = *p_head;
 
      if ((tail->elt_type() == PRMClassElement< GUM_SCALAR >::prm_refslot)
          || (head->elt_type() == PRMClassElement< GUM_SCALAR >::prm_refslot)) {
        GUM_ERROR(OperationNotAllowed,
                  "a PRMReferenceSlot<GUM_SCALAR> can "
                  "not on neither side of an arc");
      }
 
      if ((tail->elt_type() == PRMClassElement< GUM_SCALAR >::prm_slotchain)
          && (head->elt_type() == PRMClassElement< GUM_SCALAR >::prm_slotchain)) {
        GUM_ERROR(OperationNotAllowed,
                  "illegal insertion of an arc between two SlotChain<GUM_SCALAR>")
      }
 
      if (!_dag_.existsArc(Arc(tail->id(), head->id()))) {
        _dag_.addArc(tail->id(), head->id());
      } else {
        GUM_ERROR(DuplicateElement, "duplicate arc " << tail_name << "->" << head_name)
      }
 
      get(tail->id()).addChild(get(head->id()));
      get(head->id()).addParent(get(tail->id()));
 
      // Defining input / output nodes
      if (tail->elt_type() == PRMClassElement< GUM_SCALAR >::prm_slotchain) {
        PRMSlotChain< GUM_SCALAR >* sc = static_cast< PRMSlotChain< GUM_SCALAR >* >(tail);
        this->setInputNode(*head, true);
        sc->end().setOutputNode(sc->end().get(sc->lastElt().safeName()), true);
      }
    }

References _dag_, _nameMap_, gum::prm::PRMClassElement< GUM_SCALAR >::elt_type(), gum::prm::PRMSlotChain< GUM_SCALAR >::end(), get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMSlotChain< GUM_SCALAR >::lastElt(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_refslot, gum::prm::PRMClassElement< GUM_SCALAR >::prm_slotchain, and gum::prm::PRMClassElementContainer< GUM_SCALAR >::setInputNode().

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::_addParent_(), gum::prm::PRMFactory< GUM_SCALAR >::addAggregator(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), and completeInheritance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ aggregates()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMAggregate< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::aggregates ( ) const

Returns the set of PRMAggregate<GUM_SCALAR> of this Class<GUM_SCALAR>.

Returns: Returns the set of PRMAggregate<GUM_SCALAR> of this Class<GUM_SCALAR>.

Definition at line 1082 of file PRMClass_tpl.h.

                                                                                       {
      return _aggregates_;
    }

References _aggregates_.

◆ attributes()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMAttribute< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::attributes ( ) const

Returns the set of PRMAttribute<GUM_SCALAR> of this Class<GUM_SCALAR>.

Returns: Returns the set of PRMAttribute<GUM_SCALAR> of this Class<GUM_SCALAR>.

Definition at line 1020 of file PRMClass_tpl.h.

                                                                                       {
      return _attributes_;
    }

References _attributes_.

◆ belongsTo()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::belongsTo ( const PRMClassElement< GUM_SCALAR > & elt ) const

virtualinherited

Returns true if elt belongs to this PRMClassElementContainer.

Parameters

elt	A PRMClassElement<GUM_SCALAR>.

Returns: true if elt beglons to this PRMClassElementContainer.

Definition at line 191 of file PRMClassElementContainer_tpl.h.

                                                        {
      try {
        return &elt == &(get(elt.safeName()));
      } catch (NotFound const&) { return false; }
    }

References get(), and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Here is the call graph for this function:

◆ completeInheritance()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::completeInheritance ( std::string_view attr )

Definition at line 296 of file PRMClass_tpl.h.

                                                                        {
      if (_superClass_) {
        auto& elt = this->get(name);
        if (!(PRMClassElement< GUM_SCALAR >::isAttribute(elt)
              || PRMClassElement< GUM_SCALAR >::isAggregate(elt))) {
          GUM_ERROR(OperationNotAllowed, "you can only complete inheritance for attributes")
        }
 
        for (const auto& prnt: super().containerDag().parents(elt.id())) {
          this->addArc(super().get(prnt).safeName(), elt.safeName());
        }
 
        if (PRMClassElement< GUM_SCALAR >::isAttribute(elt)) {
          auto& attr       = static_cast< PRMAttribute< GUM_SCALAR >& >(elt);
          auto& super_attr = static_cast< const PRMAttribute< GUM_SCALAR >& >(super().get(name));
          attr.copyCpf(*_bijection_, super_attr);
        }
      }
    }

References _bijection_, _superClass_, addArc(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::PRMAttribute< GUM_SCALAR >::copyCpf(), get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMObject::name(), and super().

Here is the call graph for this function:

◆ containerDag()

template<GUM_Numeric GUM_SCALAR>

const DAG & gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag ( ) const

virtualinherited

Returns the gum::DAG of this PRMClassElementContainer.

Be very careful when using NodeId with PRMClassElement<GUM_SCALAR>: there is no guarantee that an inherited PRMClassElement<GUM_SCALAR> will have the same NodeId than its superclass counterpart.

When dealing with different classes and interfaces ALWAYS use safe-name as identifier.

Returns: the DAG of this PRMClassElementContainer.

Definition at line 199 of file PRMClassElementContainer_tpl.h.

                                                                          {
      return dag_();
    }

References dag_().

Referenced by gum::prm::ClassDependencyGraph< GUM_SCALAR >::_addArcs_(), gum::prm::PRMClass< GUM_SCALAR >::_inheritClass_(), gum::prm::ClassBayesNet< GUM_SCALAR >::_init_(), gum::prm::SVE< GUM_SCALAR >::_initLiftedNodes_(), gum::prm::SVED< GUM_SCALAR >::_initLiftedNodes_(), gum::prm::PRMClass< GUM_SCALAR >::_overloadReference_(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMClass< GUM_SCALAR >::completeInheritance(), exists(), and operator<<().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyIOFlags_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClassElementContainer< GUM_SCALAR >::copyIOFlags_ ( const PRMClassElementContainer< GUM_SCALAR > & c )

protectedvirtualinherited

Copy the IO Flags of c in this PRMClassElementContainer.

Parameters

c	A PRMClassElementContainer.

Definition at line 58 of file PRMClassElementContainer_tpl.h.

                                                         {
      for (const auto& flag: c._IOFlags_)
        setIOFlag_(get(flag.first), flag.second);
    }

References PRMClassElementContainer(), _IOFlags_, get(), and setIOFlag_().

Referenced by gum::prm::PRMClass< GUM_SCALAR >::_inheritClass_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dag_() [1/2]

template<GUM_Numeric GUM_SCALAR>

const DAG & gum::prm::PRMClass< GUM_SCALAR >::dag_ ( ) const

overrideprotectedvirtual

returns a constant reference over this interface's dag.

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 976 of file PRMClass_tpl.h.

                                                  {
      return _dag_;
    }

References _dag_.

◆ dag_() [2/2]

template<GUM_Numeric GUM_SCALAR>

DAG & gum::prm::PRMClass< GUM_SCALAR >::dag_ ( )

overrideprotectedvirtual

Returns a non constant reference over this PRMInterface<GUM_SCALAR>'s DAG.

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 981 of file PRMClass_tpl.h.

                                      {
      return _dag_;
    }

References _dag_.

◆ enum2str()

INLINE std::string gum::prm::PRMObject::enum2str ( prm_type type )

staticinherited

Returns the string representation of a PRMObject.

Definition at line 75 of file PRMObject_inl.h.

                                                      {
      switch (type) {
        case prm_type::CLASS : return "PRMType::CLASS";
 
        case prm_type::CLASS_ELT : return "PRMType::CLASS_ELT";
 
        case prm_type::TYPE : return "PRMType::TYPE";
 
        case prm_type::SYSTEM : return "PRMType::SYSTEM";
 
        case prm_type::INSTANCE : return "PRMType::INSTANCE";
 
        case prm_type::PRM_INTERFACE : return "PRMType::PRM_INTERFACE";
 
        default : return "unknown";
      }
    }

References CLASS, CLASS_ELT, INSTANCE, PRM_INTERFACE, SYSTEM, and TYPE.

Referenced by gum::prm::operator<<().

Here is the caller graph for this function:

◆ exists() [1/2]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists ( NodeId id ) const

virtualinherited

Returns true if a member with the given id exists in this PRMClassElementContainer or in the PRMClassElementContainer hierarchy.

Parameters

id A NodeId.

Returns: true if id matches a PRMClassElement<GUM_SCALAR>.

Definition at line 178 of file PRMClassElementContainer_tpl.h.

                                                                       {
      return containerDag().exists(id);
    }

References containerDag().

Here is the call graph for this function:

◆ exists() [2/2]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists ( std::string_view name ) const

virtualinherited

Returns true if a member with the given name exists in this PRMClassElementContainer or in the PRMClassElementContainer hierarchy.

Definition at line 183 of file PRMClassElementContainer_tpl.h.

                                                                                 {
      try {
        get(name);
        return true;
      } catch (NotFound const&) { return false; }
    }

References get(), and gum::prm::PRMObject::name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extensions()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMClass< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::extensions ( ) const

Returns the set of Class<GUM_SCALAR> which are direct sub-Class<GUM_SCALAR> of this Class<GUM_SCALAR>.

Definition at line 1181 of file PRMClass_tpl.h.

                                                                                   {
      return _extensions_;
    }

References _extensions_.

◆ findAllSubtypes_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::findAllSubtypes_ ( Set< PRMClassElementContainer< GUM_SCALAR > * > & set )

overrideprotectedvirtual

Fills set with all the subtypes of this Class<GUM_SCALAR>.

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 932 of file PRMClass_tpl.h.

                                                             {
      for (auto ext: _extensions_) {
        set.insert(ext);
        ext->findAllSubtypes_(set);
      }
    }

References gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), and _extensions_.

Here is the call graph for this function:

◆ get() [1/4]

template<GUM_Numeric GUM_SCALAR>

const PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::get ( NodeId id ) const

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 993 of file PRMClass_tpl.h.

                                                                                    {
      auto p = _nodeIdMap_.tryGet(id);
      if (!p) {
        GUM_ERROR(NotFound, "no ClassElement<GUM_SCALAR> with the given NodeId (" << id << ")");
      }
      return **p;
    }

References _nodeIdMap_, and GUM_ERROR.

◆ get() [2/4]

template<GUM_Numeric GUM_SCALAR>

PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::get ( NodeId id )

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 986 of file PRMClass_tpl.h.

                                                                        {
      auto p = _nodeIdMap_.tryGet(id);
      if (!p) { GUM_ERROR(NotFound, "no ClassElement<GUM_SCALAR> with the given NodeId") }
      return **p;
    }

References _nodeIdMap_, and GUM_ERROR.

Referenced by _checkInterface_(), gum::prm::PRMFactory< GUM_SCALAR >::_checkInterfaceImplementation_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_checkLocalParent_(), gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::_checkParameters_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_checkRawCPT_(), gum::prm::ClassBayesNet< GUM_SCALAR >::_init_(), gum::prm::SVE< GUM_SCALAR >::_initLiftedNodes_(), gum::prm::SVED< GUM_SCALAR >::_initLiftedNodes_(), _overloadReference_(), gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInputs_(), addArc(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound(), completeInheritance(), isCastDescendant(), operator[](), operator[](), operator[](), and operator[]().

Here is the caller graph for this function:

◆ get() [3/4]

template<GUM_Numeric GUM_SCALAR>

const PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::get ( std::string_view name ) const

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(const std::string&).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1011 of file PRMClass_tpl.h.

                                                                                              {
      auto p = _nameMap_.tryGet(name);
      if (!p) {
        GUM_ERROR(NotFound, "no ClassElement<GUM_SCALAR> with the given name (" << name << ")");
      }
      return **p;
    }

References _nameMap_, GUM_ERROR, and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ get() [4/4]

template<GUM_Numeric GUM_SCALAR>

PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::get ( std::string_view name )

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(const std::string&).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1002 of file PRMClass_tpl.h.

                                                                                  {
      auto p = _nameMap_.tryGet(name);
      if (!p) {
        GUM_ERROR(NotFound, "no ClassElement<GUM_SCALAR> with the given name (" << name << ")");
      }
      return **p;
    }

References _nameMap_, GUM_ERROR, and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ getIOFlag_() [1/2]

template<GUM_Numeric GUM_SCALAR>

std::pair< bool, bool > & gum::prm::PRMClassElementContainer< GUM_SCALAR >::getIOFlag_ ( const PRMClassElement< GUM_SCALAR > & elt )

protectedvirtualinherited

Returns the IO flags of a PRMClassElement<GUM_SCALAR>.

Parameters

elt	The PRMClassElement<GUM_SCALAR>.

Returns: elt's IO flags.

Exceptions

NotFound Raised if elt does not have any IO flags.

Definition at line 151 of file PRMClassElementContainer_tpl.h.

                                                  {
      auto p = _IOFlags_.tryGet(elt.safeName());
      if (!p) GUM_ERROR(NotFound, "this ClassElement<GUM_SCALAR> does not have any IO flags")
      return *p;
    }

References _IOFlags_, GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by gum::prm::PRMClass< GUM_SCALAR >::_addIOInterfaceFlags_(), gum::prm::PRMClass< GUM_SCALAR >::isOutputNode(), and gum::prm::PRMInterface< GUM_SCALAR >::isOutputNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getIOFlag_() [2/2]

template<GUM_Numeric GUM_SCALAR>

const std::pair< bool, bool > & gum::prm::PRMClassElementContainer< GUM_SCALAR >::getIOFlag_ ( const PRMClassElement< GUM_SCALAR > & elt ) const

protectedvirtualinherited

Returns the IO flags of a PRMClassElement<GUM_SCALAR>.

Parameters

elt	The PRMClassElement<GUM_SCALAR>.

Returns: elt's IO flags.

Exceptions

NotFound Raised if elt does not have any IO flags.

Definition at line 159 of file PRMClassElementContainer_tpl.h.

                                                        {
      auto p = _IOFlags_.tryGet(elt.safeName());
      if (!p) GUM_ERROR(NotFound, "this ClassElement<GUM_SCALAR> does not have any IO flags")
      return *p;
    }

References _IOFlags_, GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Here is the call graph for this function:

◆ implements()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMInterface< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::implements ( ) const

Returns the Set of PRMInterface<GUM_SCALAR> implemented by this Class<GUM_SCALAR>.

Returns: Returns the Set of PRMInterface<GUM_SCALAR> implemented by this Class<GUM_SCALAR>.

Exceptions

NotFound Raised if this Class<GUM_SCALAR> doesn't implement any PRMInterface<GUM_SCALAR>.

Definition at line 1106 of file PRMClass_tpl.h.

                                                                                       {
      if (_implements_) {
        return *_implements_;
      } else {
        GUM_ERROR(NotFound, "this Class does not implement any Interface<GUM_SCALAR>")
      }
    }

References _implements_, and GUM_ERROR.

Referenced by _addCastDescendants_(), gum::prm::PRMFactory< GUM_SCALAR >::_checkInterfaceImplementation_(), _checkInterfaces_(), and _checkRefInterfaces_().

Here is the caller graph for this function:

◆ inheritAggregates()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::inheritAggregates ( )

Definition at line 237 of file PRMClass_tpl.h.

                                                   {
      if (_superClass_) {
        for (const auto c_agg: _superClass_->_aggregates_) {
          PRMAggregate< GUM_SCALAR >* agg = nullptr;
 
          try {
            agg = new PRMAggregate< GUM_SCALAR >(c_agg->name(),
                                                 c_agg->agg_type(),
                                                 c_agg->type(),
                                                 c_agg->label());
          } catch (OperationNotAllowed const&) {
            agg = new PRMAggregate< GUM_SCALAR >(c_agg->name(), c_agg->agg_type(), c_agg->type());
            agg->sharedLabel(c_agg->sharedLabel());
            agg->setLabel(c_agg->labelValue());
          }
 
          _bijection_->insert(&(c_agg->type().variable()), &(agg->type().variable()));
          agg->setId(c_agg->id());
          _dag_.addNodeWithId(agg->id());
          _nodeIdMap_.insert(agg->id(), agg);
          _aggregates_.insert(agg);
 
          if (_superClass_->_nameMap_[c_agg->name()] == _superClass_->_nameMap_[c_agg->safeName()])
            _nameMap_.insert(agg->name(), agg);
 
          _nameMap_.insert(agg->safeName(), agg);
        }
      }
    }

References _aggregates_, _bijection_, _dag_, _nameMap_, _nodeIdMap_, _superClass_, gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMClassElement< GUM_SCALAR >::setId(), gum::prm::PRMAggregate< GUM_SCALAR >::setLabel(), gum::prm::PRMAggregate< GUM_SCALAR >::sharedLabel(), gum::prm::PRMAggregate< GUM_SCALAR >::type(), and gum::prm::PRMType::variable().

Here is the call graph for this function:

◆ inheritAttributes()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::inheritAttributes ( )

Definition at line 209 of file PRMClass_tpl.h.

                                                   {
      if (_superClass_) {
        for (const auto c_attr: _superClass_->_attributes_) {
          // using multiDimSparse to prevent unecessary memory allocation for
          // large arrays (the tensors are copied latter)
          auto attr = c_attr->newFactory(*this);
 
          _bijection_->insert(&(c_attr->type().variable()), &(attr->type().variable()));
          attr->setId(c_attr->id());
          try {
            _dag_.addNodeWithId(attr->id());
          } catch (gum::Exception&) {
            // Node reserved by an interface
          }
          _nodeIdMap_.insert(attr->id(), attr);
          _attributes_.insert(attr);
 
          if (_superClass_->_nameMap_[c_attr->name()]
              == _superClass_->_nameMap_[c_attr->safeName()]) {
            _nameMap_.insert(attr->name(), attr);
          }
 
          _nameMap_.insert(attr->safeName(), attr);
        }
      }
    }

References _attributes_, _bijection_, _dag_, _nameMap_, _nodeIdMap_, and _superClass_.

◆ inheritParameters()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::inheritParameters ( )

Definition at line 190 of file PRMClass_tpl.h.

                                                   {
      if (_superClass_) {
        // Copying parameters
        for (const auto c_param: _superClass_->_parameters_) {
          auto param = new PRMParameter< GUM_SCALAR >(c_param->name(),
                                                      c_param->valueType(),
                                                      c_param->value());
 
          _parameters_.insert(param);
 
          param->setId(c_param->id());
          _dag_.addNodeWithId(param->id());
          _nodeIdMap_.insert(param->id(), param);
          _nameMap_.insert(param->name(), param);
        }
      }
    }

References _dag_, _nameMap_, _nodeIdMap_, _parameters_, and _superClass_.

◆ inheritReferenceSlots()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::inheritReferenceSlots ( )

Definition at line 164 of file PRMClass_tpl.h.

                                                       {
      if (_superClass_) {
        // Copying reference slots
        for (const auto c_refslot: _superClass_->_referenceSlots_) {
          auto ref = new PRMReferenceSlot< GUM_SCALAR >(
              c_refslot->name(),
              const_cast< PRMClassElementContainer< GUM_SCALAR >& >(c_refslot->slotType()),
              c_refslot->isArray());
 
          ref->setId(c_refslot->id());
          // Not reserved by an interface
          if (!_dag_.existsNode(ref->id())) { _dag_.addNodeWithId(ref->id()); }
          _nodeIdMap_.insert(ref->id(), ref);
          _referenceSlots_.insert(ref);
 
          if (_superClass_->_nameMap_[c_refslot->name()]
              == _superClass_->_nameMap_[c_refslot->safeName()]) {
            _nameMap_.insert(ref->name(), ref);
          }
 
          _nameMap_.insert(ref->safeName(), ref);
        }
      }
    }

References gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _dag_, _nameMap_, _nodeIdMap_, _referenceSlots_, and _superClass_.

Here is the call graph for this function:

◆ inheritSlotChains()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::inheritSlotChains ( )

Definition at line 268 of file PRMClass_tpl.h.

                                                   {
      if (_superClass_) {
        // Copying slot chains
        for (const auto c_sc: _superClass_->_slotChains_) {
          // Because of aggregators, some slotchains may exists already
          if (!(_nameMap_.exists(c_sc->name()) && _nameMap_.exists(c_sc->safeName()))) {
            // We just need to change the first PRMReferenceSlot<GUM_SCALAR> in
            // the
            // chain
            auto chain = c_sc->chain();
 
            chain.setAtPos(0, _nameMap_[c_sc->chain().front()->name()]);
 
            auto sc = new PRMSlotChain< GUM_SCALAR >(c_sc->name(), chain);
            _bijection_->insert(&(c_sc->type().variable()), &(sc->type().variable()));
            sc->setId(c_sc->id());
            _dag_.addNodeWithId(sc->id());
            _nodeIdMap_.insert(sc->id(), sc);
            _slotChains_.insert(sc);
 
            if (!_nameMap_.exists(sc->name())) { _nameMap_.insert(sc->name(), sc); }
            if (!_nameMap_.exists(sc->safeName())) { _nameMap_.insert(sc->safeName(), sc); }
          }
        }
      }
    }

References _bijection_, _dag_, _nameMap_, _nodeIdMap_, _slotChains_, and _superClass_.

◆ initializeInheritance()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::initializeInheritance ( )

Definition at line 146 of file PRMClass_tpl.h.

                                                       {
      if (_superClass_) {
        _superClass_->_addExtension_(this);
        // Adding implemented interfaces, if any
        if (_superClass_->_implements_) {
          if (!_implements_) {
            _implements_ = new Set< PRMInterface< GUM_SCALAR >* >(*(_superClass_->_implements_));
          } else {
            for (auto i: *(_superClass_->_implements_)) {
              _implements_->insert(i);
            }
          }
        }
      }
      if (_implements_) { _implementInterfaces_(true); }
    }

References _implementInterfaces_(), _implements_, and _superClass_.

Here is the call graph for this function:

◆ isCastDescendant()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClass< GUM_SCALAR >::isCastDescendant ( std::string_view safe_name ) const

Return true if the attribute named safe_name is a cast descendant.

Cast descendant are automatically added PRMAttribute<GUM_SCALAR> for type casting.

Parameters

safe_name The safe name of an PRMAttribute<GUM_SCALAR> of this class.

Returns: true if safe_name is a cast descendant.

Exceptions

NotFound Raised if safe_name does not name an PRMAttribute<GUM_SCALAR> in this Class<GUM_SCALAR>.

Definition at line 1191 of file PRMClass_tpl.h.

                                                                                {
      const PRMClassElement< GUM_SCALAR >& elt = get(safe_name);
 
      try {
        return elt.type().name() == get(elt.name()).type().name();
      } catch (OperationNotAllowed const&) {
        GUM_ERROR(NotFound, "no attribute with the given name")
      }
    }

References get(), GUM_ERROR, gum::prm::PRMObject::name(), gum::prm::PRMType::name(), and gum::prm::PRMClassElement< GUM_SCALAR >::type().

Here is the call graph for this function:

◆ isClass()

INLINE bool gum::prm::PRMObject::isClass ( const PRMObject & obj )

staticinherited

Returns true if obj_ptr is of type Class.

Definition at line 93 of file PRMObject_inl.h.

                                                       {
      return obj.obj_type() == prm_type::CLASS;
    }

References PRMObject().

Referenced by gum::prm::PRMClass< GUM_SCALAR >::scope(), and gum::prm::PRMFactory< GUM_SCALAR >::startAttribute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isInnerNode()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::isInnerNode ( const PRMClassElement< GUM_SCALAR > & elt ) const

virtualinherited

Returns true if the node is an inner node.

PRMAttribute or PRMAggregate can either be input, output, both or internal nodes.

By defaut, attributes and aggregates are inner nodes.

Parameters

elt	A PRMClassElement<GUM_SCALAR>.

Returns: true if elt is an inner node.

Exceptions

NotFound	Raised if NodeId does'nt match any PRMClassElement<GUM_SCALAR> in this.
WrongClassElement	Raised if NodeId is neither an PRMAttribute nor an PRMAggregate.

Definition at line 137 of file PRMClassElementContainer_tpl.h.

                                                        {
      auto p = _IOFlags_.tryGet(elt.safeName());
      if (!p) return true;
      return !(p->first || p->second);
    }

References _IOFlags_, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by gum::prm::SVE< GUM_SCALAR >::_initLiftedNodes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isInputNode()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::isInputNode ( const PRMClassElement< GUM_SCALAR > & elt ) const

virtualinherited

Returns true if the node is an input node.

PRMAttribute or PRMAggregate can either be input, output, both or internal nodes.

By defaut, attributes and aggregates are inner nodes.

Parameters

elt	A PRMClassElement<GUM_SCALAR>.

Returns: Returns true if id is an input node.

Definition at line 89 of file PRMClassElementContainer_tpl.h.

                                                        {
      auto p = _IOFlags_.tryGet(elt.safeName());
      if (!p) return false;
      return p->first;
    }

References _IOFlags_, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Here is the call graph for this function:

◆ isInstance()

INLINE bool gum::prm::PRMObject::isInstance ( const PRMObject & obj )

staticinherited

Returns true if obj_ptr is of type PRMInstance.

Definition at line 101 of file PRMObject_inl.h.

                                                          {
      return obj.obj_type() == prm_type::INSTANCE;
    }

References PRMObject(), INSTANCE, and obj_type().

Here is the call graph for this function:

◆ isInterface()

INLINE bool gum::prm::PRMObject::isInterface ( const PRMObject & obj )

staticinherited

Returns true if obj_ptr is of type PRMInterface.

Definition at line 97 of file PRMObject_inl.h.

                                                           {
      return obj.obj_type() == prm_type::PRM_INTERFACE;
    }

◆ isOutputNode()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClass< GUM_SCALAR >::isOutputNode ( const PRMClassElement< GUM_SCALAR > & elt ) const

overridevirtual

Returns true if elt is an output node.

Parameters

elt	A node of this class.

Returns: Returns true if elt is an output node.

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1202 of file PRMClass_tpl.h.

                                                                                            {
      try {
        if (!this->getIOFlag_(elt).second) {
          if (_implements_) {
            for (auto i: *_implements_) {
              if (i->isOutputNode(elt)) { return true; }
            }
          }
 
          if (_superClass_ && (_superClass_->isOutputNode(elt))) { return true; }
 
        } else {
          return true;
        }
      } catch (NotFound const&) {}
      return false;
    }

References _implements_, _superClass_, and gum::prm::PRMClassElementContainer< GUM_SCALAR >::getIOFlag_().

Referenced by gum::prm::SVE< GUM_SCALAR >::_initLiftedNodes_(), and gum::prm::SVED< GUM_SCALAR >::_initLiftedNodes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isSubTypeOf()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClass< GUM_SCALAR >::isSubTypeOf ( const PRMClassElementContainer< GUM_SCALAR > & cec ) const

overridevirtual

Test if this Class<GUM_SCALAR> is a subclass of cec.

If cec is a Class<GUM_SCALAR> then this Class<GUM_SCALAR> is a subclass of cec if they are equal or there exists a superclass of this Class<GUM_SCALAR> which is equal to cec.

If cec is an PRMInterface<GUM_SCALAR> then this Class<GUM_SCALAR> is a subclass of cec if it implements cec or if there exists a superclass of this Class<GUM_SCALAR> which implements cec.

Parameters

cec	The PRMClassElementContainer<GUM_SCALAR> for which we determine if this Class<GUM_SCALAR> is a subclass of it.

Returns: Returns true if this Class<GUM_SCALAR> is a subclass of cec.

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 446 of file PRMClass_tpl.h.

                                                                 {
      switch (cec.obj_type()) {
        case PRMObject::prm_type::CLASS : {
          const PRMClass< GUM_SCALAR >* current = this;
 
          while (current != 0) {
            if (current == &(cec)) return true;
 
            current = current->_superClass_;
          }
 
          return false;
        }
 
        case PRMObject::prm_type::PRM_INTERFACE : {
          if (_implements_ != nullptr) {
            const PRMInterface< GUM_SCALAR >& i
                = static_cast< const PRMInterface< GUM_SCALAR >& >(cec);
 
            if (_implements_->exists(const_cast< PRMInterface< GUM_SCALAR >* >(&i))) return true;
 
            for (const auto impl: *_implements_)
              if (impl->isSubTypeOf(i)) return true;
          }
 
          return false;
        }
 
        default : {
          GUM_ERROR(FatalError, "unknown ClassElementContainer<GUM_SCALAR>")
        }
      }
    }

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), _implements_, _superClass_, gum::prm::PRMObject::CLASS, GUM_ERROR, gum::prm::PRMObject::obj_type(), gum::prm::PRMObject::PRM_INTERFACE, and PRMInterface< GUM_SCALAR >.

Referenced by _implementInterfaces_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isSuperTypeOf()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::isSuperTypeOf ( const PRMClassElementContainer< GUM_SCALAR > & cec ) const

virtualinherited

Test if this PRMClassElementContainer is a super type of cec.

This returns cec.isSubTypeOf(*this).

Parameters

cec

Returns: return true if this PRMClassElementContainer is a super type of cec.

Definition at line 145 of file PRMClassElementContainer_tpl.h.

                                                                 {
      return cec.isSubTypeOf(*this);
    }

References PRMClassElementContainer(), and isSubTypeOf().

Here is the call graph for this function:

◆ LEFT_CAST()

INLINE std::string gum::prm::PRMObject::LEFT_CAST ( )

staticinherited

Enumeration of the different types of objects handled by a PRM.

The "all" type is used to tell that we want any kind of PRMType (useful with iterators for example). No PRMObject will ever have "all" as type.

Definition at line 71 of file PRMObject_inl.h.

71{ return "("; }

Referenced by gum::prm::PRMAggregate< GUM_SCALAR >::PRMAggregate(), gum::prm::PRMAggregate< GUM_SCALAR >::PRMAggregate(), gum::prm::PRMFormAttribute< GUM_SCALAR >::PRMFormAttribute(), gum::prm::PRMReferenceSlot< GUM_SCALAR >::PRMReferenceSlot(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::PRMScalarAttribute(), gum::prm::PRMSlotChain< GUM_SCALAR >::PRMSlotChain(), gum::prm::PRMClassElement< GUM_SCALAR >::cast(), and gum::prm::decomposePath().

Here is the caller graph for this function:

◆ name() [1/2]

INLINE const std::string & gum::prm::PRMObject::name ( ) const

inherited

Returns the name of this object.

Definition at line 57 of file PRMObject_inl.h.

57{ return _name_; }

gum::prm::PRMObject::_name_

std::string _name_

Definition PRMObject.h:193

References _name_.

◆ name() [2/2]

INLINE void gum::prm::PRMObject::name ( std::string_view name )

inherited

Change the name of the PRM Object.

Warning: Don't do this unless you know what you are doing !

Definition at line 61 of file PRMObject_inl.h.

61{ _name_ = name; }

References _name_, and name().

Here is the call graph for this function:

◆ obj_type()

template<GUM_Numeric GUM_SCALAR>

PRMObject::prm_type gum::prm::PRMClass< GUM_SCALAR >::obj_type ( ) const

overridevirtual

Implementation of pure virtual method of PRMObject.

Implements gum::prm::PRMObject.

Definition at line 971 of file PRMClass_tpl.h.

                                                                      {
      return PRMObject::prm_type::CLASS;
    }

References gum::prm::PRMObject::CLASS.

◆ operator!=()

INLINE bool gum::prm::PRMObject::operator!= ( const PRMObject & obj ) const

inherited

To PRMObject are equal if they have the same name (which is unique).

Definition at line 69 of file PRMObject_inl.h.

69{ return _name_ != obj.name(); }

References PRMObject(), _name_, and name().

Here is the call graph for this function:

◆ operator=() [1/2]

template<GUM_Numeric GUM_SCALAR>

PRMClass< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator= ( const PRMClass< GUM_SCALAR > && source )

delete

Move operator. Don't use it.

References PRMClass(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::PRMClassElementContainer(), and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ operator=() [2/2]

template<GUM_Numeric GUM_SCALAR>

PRMClass< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator= ( const PRMClass< GUM_SCALAR > & source )

delete

Copy operator. Don't use it.

References PRMClass().

Here is the call graph for this function:

◆ operator==()

INLINE bool gum::prm::PRMObject::operator== ( const PRMObject & obj ) const

inherited

To PRMObject are equal if they have the same name (which is unique).

Definition at line 65 of file PRMObject_inl.h.

65{ return _name_ == obj.name(); }

References PRMObject(), _name_, and name().

Here is the call graph for this function:

◆ operator[]() [1/4]

template<GUM_Numeric GUM_SCALAR>

const PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator[] ( NodeId id ) const

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1120 of file PRMClass_tpl.h.

                                                                                           {
      return get(id);
    }

References get().

Here is the call graph for this function:

◆ operator[]() [2/4]

template<GUM_Numeric GUM_SCALAR>

PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator[] ( NodeId id )

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1115 of file PRMClass_tpl.h.

                                                                               {
      return get(id);
    }

References get().

Here is the call graph for this function:

◆ operator[]() [3/4]

template<GUM_Numeric GUM_SCALAR>

const PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator[] ( std::string_view name ) const

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](const std::string&).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1131 of file PRMClass_tpl.h.

                                                                    {
      return get(name);
    }

References get(), and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ operator[]() [4/4]

template<GUM_Numeric GUM_SCALAR>

PRMClassElement< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::operator[] ( std::string_view name )

overridevirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](const std::string&).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 1125 of file PRMClass_tpl.h.

                                                                                         {
      return get(name);
    }

References get(), and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ overload()

template<GUM_Numeric GUM_SCALAR>

NodeId gum::prm::PRMClass< GUM_SCALAR >::overload ( PRMClassElement< GUM_SCALAR > * elt )

overridevirtual

See gum::prm::overload(PRMClassElement<GUM_SCALAR>*).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 713 of file PRMClass_tpl.h.

                                                                                     {
      if (!_superClass_) {
        GUM_ERROR(OperationNotAllowed, "overload is possible only with subclasses")
      }
      if (!super().exists(overloader->name())) {
        GUM_ERROR(OperationNotAllowed, "found no ClassElement<GUM_SCALAR> to overload")
      }
 
      PRMClassElement< GUM_SCALAR >* overloaded = _nameMap_[overloader->name()];
      if (overloaded == overloader) {
        GUM_ERROR(DuplicateElement, "dupplicate ClassElement " << overloader->name())
      }
      // Checking overload legality
      if (!_checkOverloadLegality_(overloaded, overloader)) {
        GUM_ERROR(OperationNotAllowed, "illegal overload")
      }
 
      switch (overloader->elt_type()) {
        case PRMClassElement< GUM_SCALAR >::prm_attribute : {
          auto overloader_attr = static_cast< PRMAttribute< GUM_SCALAR >* >(overloader);
          auto overloaded_attr = static_cast< PRMAttribute< GUM_SCALAR >* >(overloaded);
          _overloadAttribute_(overloader_attr, overloaded_attr);
          _addIOInterfaceFlags_(overloader);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_aggregate : {
          _overloadAggregate_(static_cast< PRMAggregate< GUM_SCALAR >* >(overloader), overloaded);
          _addIOInterfaceFlags_(overloader);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_refslot : {
          //  _checkOverloadLegality_ guaranties that overloaded is a
          // PRMReferenceSlot<GUM_SCALAR>
          auto overloader_ref = static_cast< PRMReferenceSlot< GUM_SCALAR >* >(overloader);
          auto overloaded_ref = static_cast< PRMReferenceSlot< GUM_SCALAR >* >(overloaded);
          _overloadReference_(overloader_ref, overloaded_ref);
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_slotchain : {
          GUM_ERROR(OperationNotAllowed, "SlotChain<GUM_SCALAR> can not be overloaded")
          break;
        }
 
        case PRMClassElement< GUM_SCALAR >::prm_parameter : {
          auto overloaded_param = static_cast< PRMParameter< GUM_SCALAR >* >(overloaded);
          auto overloader_param = static_cast< PRMParameter< GUM_SCALAR >* >(overloader);
          _overloadParameter_(overloader_param, overloaded_param);
          break;
        }
        default : {
          GUM_ERROR(OperationNotAllowed, "unknown ClassElement<GUM_SCALAR> type")
        }
      }
 
      return overloader->id();
    }

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::addAggregator(), and gum::prm::PRMFactory< GUM_SCALAR >::startAggregator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parameters()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMParameter< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::parameters ( ) const

Returns the set of parameters of this Class<GUM_SCALAR>.

Returns: Returns the set of parameters of this Class<GUM_SCALAR>.

Definition at line 1025 of file PRMClass_tpl.h.

                                                                                       {
      return _parameters_;
    }

References _parameters_.

Referenced by scope().

Here is the caller graph for this function:

◆ referenceSlots()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMReferenceSlot< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::referenceSlots ( ) const

Returns the set of PRMReferenceSlot<GUM_SCALAR> of this Class<GUM_SCALAR>.

Returns: Returns the set of PRMReferenceSlot<GUM_SCALAR> of this Class<GUM_SCALAR>.

Definition at line 1087 of file PRMClass_tpl.h.

                                                                                               {
      return _referenceSlots_;
    }

References _referenceSlots_.

Referenced by scope().

Here is the caller graph for this function:

◆ RIGHT_CAST()

INLINE std::string gum::prm::PRMObject::RIGHT_CAST ( )

staticinherited

Enumeration of the different types of objects handled by a PRM.

The "all" type is used to tell that we want any kind of PRMType (useful with iterators for example). No PRMObject will ever have "all" as type.

Definition at line 73 of file PRMObject_inl.h.

73{ return ")"; }

Referenced by gum::prm::PRMAggregate< GUM_SCALAR >::PRMAggregate(), gum::prm::PRMAggregate< GUM_SCALAR >::PRMAggregate(), gum::prm::PRMFormAttribute< GUM_SCALAR >::PRMFormAttribute(), gum::prm::PRMReferenceSlot< GUM_SCALAR >::PRMReferenceSlot(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::PRMScalarAttribute(), gum::prm::PRMSlotChain< GUM_SCALAR >::PRMSlotChain(), gum::prm::PRMClassElement< GUM_SCALAR >::cast(), and gum::prm::decomposePath().

Here is the caller graph for this function:

◆ scope()

template<GUM_Numeric GUM_SCALAR>

HashTable< std::string, const PRMParameter< GUM_SCALAR > * > gum::prm::PRMClass< GUM_SCALAR >::scope ( ) const

Returns all the parameters in the scope of this class.

&return all the parameters in the scope of this class.

Definition at line 1043 of file PRMClass_tpl.h.

                                            {
      HashTable< std::string, const PRMParameter< GUM_SCALAR >* > params;
 
      for (const auto p: parameters()) {
        params.insert(p->name(), p);
      }
 
      std::queue< ParamScopeData< GUM_SCALAR > > queue;
 
      for (const auto ref: referenceSlots()) {
        if (PRMObject::isClass(ref->slotType())) {
          queue.push(ParamScopeData< GUM_SCALAR >("", *ref, 1));
        }
      }
 
      while (!queue.empty()) {
        auto data = queue.front();
        queue.pop();
 
        if (data.depth < 5) {
          for (const auto p: data.c->parameters()) {
            params.insert(data.prefix + p->name(), p);
          }
 
          for (const auto ref: data.c->referenceSlots()) {
            if (PRMObject::isClass(ref->slotType())) {
              queue.push(ParamScopeData< GUM_SCALAR >(data.prefix, *ref, data.depth + 1));
            }
          }
        } else {
          // @todo depth>5 is a workaround. Cycle detection is needed here !
          GUM_ERROR(FatalError, "Depth limit reached when looking up parameters")
        }
      }
 
      return params;
    }

References GUM_ERROR, gum::HashTable< Key, Val >::insert(), gum::prm::PRMObject::isClass(), parameters(), and referenceSlots().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_checkRawCPT_(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_checkRuleCPT_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setInputNode()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClassElementContainer< GUM_SCALAR >::setInputNode	(	const PRMClassElement< GUM_SCALAR > &	elt,
		bool	b )

virtualinherited

Set the input flag value of id at b.

PRMAttribute or PRMAggregate can either be input, output, both or internal nodes.

By defaut, attributes and aggregates are inner nodes.

Parameters

elt	A PRMClassElement<GUM_SCALAR>.
b	The flag value.

Exceptions

NotFound	Raised if id does'nt match any PRMClassElement<GUM_SCALAR> in this.
WrongClassElement	Raised if NodeId is neither an PRMAttribute nor an PRMAggregate.

Definition at line 97 of file PRMClassElementContainer_tpl.h.

                                                {
      if (!exists(elt.safeName())) {
        GUM_ERROR(NotFound, ": <" + elt.safeName() + "> is not in <" + name() + ">")
      } else if (PRMClassElement< GUM_SCALAR >::isAttribute(elt)
                 || PRMClassElement< GUM_SCALAR >::isAggregate(elt)) {
        if (auto p = _IOFlags_.tryGet(elt.safeName())) {
          p->first = b;
        } else {
          setIOFlag_(elt, std::make_pair(b, false));
        }
      } else {
        GUM_ERROR(WrongClassElement, "given id is not an PRMAttribute or an PRMAggregate")
      }
    }

References _IOFlags_, exists(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), and setIOFlag_().

Referenced by gum::prm::PRMClass< GUM_SCALAR >::addArc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setIOFlag_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClassElementContainer< GUM_SCALAR >::setIOFlag_	(	const PRMClassElement< GUM_SCALAR > &	elt,
		const std::pair< bool, bool > &	flags )

protectedvirtualinherited

Defines the IO flags of a PRMClassElement<GUM_SCALAR>.

Parameters

elt	The PRMClassElement<GUM_SCALAR>.
flags	The IO flags of elt. Overwrite any existing flags.

Returns: elt's IO flags.

Exceptions

NotFound Raised if elt does not have any IO flags.

Definition at line 168 of file PRMClassElementContainer_tpl.h.

                                                                                               {
      if (auto p = _IOFlags_.tryGet(elt.safeName())) {
        *p = flags;
      } else {
        _IOFlags_.insert(elt.safeName(), flags);
      }
    }

References _IOFlags_, and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by gum::prm::PRMClass< GUM_SCALAR >::_addIOInterfaceFlags_(), copyIOFlags_(), setInputNode(), and setOutputNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setOutputNode()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClassElementContainer< GUM_SCALAR >::setOutputNode	(	const PRMClassElement< GUM_SCALAR > &	elt,
		bool	b )

virtualinherited

Set the output flag value of id at b.

PRMAttribute or PRMAggregate can either be input, output, both or internal nodes.

By defaut, attributes and aggregates are inner nodes.

Parameters

elt	A PRMClassElement<GUM_SCALAR>.
b	The flag value.

Exceptions

NotFound	Raised if id does'nt match any PRMClassElement<GUM_SCALAR> in this.
WrongClassElement	Raised if NodeId is neither an PRMAttribute nor an PRMAggregate.

Definition at line 115 of file PRMClassElementContainer_tpl.h.

                                                {
      if (!exists(elt.safeName())) {
        GUM_ERROR(NotFound, "<" + elt.safeName() + "> is not in <" + name() + ">")
      } else if (PRMClassElement< GUM_SCALAR >::isAttribute(elt)
                 || PRMClassElement< GUM_SCALAR >::isAggregate(elt)) {
        if (auto p = _IOFlags_.tryGet(elt.safeName())) {
          p->second = b;
        } else {
          setIOFlag_(elt, std::make_pair(false, b));
        }
 
        if (b) { updateDescendants_(elt); }
      } else {
        GUM_ERROR(WrongClassElement,
                  "given ClassElement<GUM_SCALAR> is not an "
                  "PRMAttribute or an PRMAggregate");
      }
    }

References _IOFlags_, exists(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), setIOFlag_(), and updateDescendants_().

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::_buildSlotChain_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotChains()

template<GUM_Numeric GUM_SCALAR>

const Set< PRMSlotChain< GUM_SCALAR > * > & gum::prm::PRMClass< GUM_SCALAR >::slotChains ( ) const

Returns the set of PRMSlotChain<GUM_SCALAR> of this Class<GUM_SCALAR>.

Returns: Returns the set of PRMSlotChain<GUM_SCALAR> of this Class<GUM_SCALAR>.

Definition at line 1092 of file PRMClass_tpl.h.

                                                                                       {
      return _slotChains_;
    }

References _slotChains_.

◆ super()

template<GUM_Numeric GUM_SCALAR>

const PRMClass< GUM_SCALAR > & gum::prm::PRMClass< GUM_SCALAR >::super ( ) const

Returns the super Class<GUM_SCALAR> of this Class<GUM_SCALAR>.

Returns: Returns the super Class<GUM_SCALAR> of this Class<GUM_SCALAR>.

Exceptions

NotFound Raised if this has no super Class<GUM_SCALAR>.

Definition at line 1097 of file PRMClass_tpl.h.

                                                                      {
      if (_superClass_) {
        return *_superClass_;
      } else {
        GUM_ERROR(NotFound, "this Class is not a subclass")
      }
    }

References PRMClass(), _superClass_, and GUM_ERROR.

Referenced by PRMClass(), PRMClass(), _addIOInterfaceFlags_(), _implementInterfaces_(), completeInheritance(), and overload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateDescendants_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMClass< GUM_SCALAR >::updateDescendants_ ( const PRMClassElement< GUM_SCALAR > & elt )

overrideprotectedvirtual

See gum::prm::PRMClassElementContainer<GUM_SCALAR>(const PRMClassElement<GUM_SCALAR>&).

Implements gum::prm::PRMClassElementContainer< GUM_SCALAR >.

Definition at line 961 of file PRMClass_tpl.h.

                                                                                            {
      // for ( const auto ext :  _extensions_ ) {
      //  // We test to prevent unnecessary recursive call from iter
      //  if ( !ext->isOutputNode( elt ) ) {
      //    ext->setOutputNode( elt, true );
      //  }
      //}
    }

◆ PRMInterface< GUM_SCALAR >

template<GUM_Numeric GUM_SCALAR>

friend class PRMInterface< GUM_SCALAR >

friend

Definition at line 470 of file PRMClass.h.

References PRMClass().

Referenced by PRMClass(), PRMClass(), _addIOInterfaceFlags_(), _checkInterface_(), _checkRefInterface_(), and isSubTypeOf().

Member Data Documentation

◆ _aggregates_

template<GUM_Numeric GUM_SCALAR>

Set< PRMAggregate< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_aggregates_

private

The sequence of aggregate.

Definition at line 370 of file PRMClass.h.

Referenced by _inheritClass_(), _overloadAggregate_(), add(), aggregates(), and inheritAggregates().

◆ _attributes_

template<GUM_Numeric GUM_SCALAR>

Set< PRMAttribute< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_attributes_

private

The sequence of PRMAttribute<GUM_SCALAR>s.

Definition at line 364 of file PRMClass.h.

Referenced by _addCastDescendants_(), _addCastDescendants_(), _inheritClass_(), _overloadAttribute_(), add(), attributes(), and inheritAttributes().

◆ _bijection_

template<GUM_Numeric GUM_SCALAR>

Bijection< const DiscreteVariable*, const DiscreteVariable* >* gum::prm::PRMClass< GUM_SCALAR >::_bijection_

private

The bijection between variables in super and variables in this The bijection's firsts are attributes in this and its seconds are attributes in c.

Definition at line 407 of file PRMClass.h.

Referenced by PRMClass(), PRMClass(), PRMClass(), PRMClass(), ~PRMClass(), completeInheritance(), inheritAggregates(), inheritAttributes(), and inheritSlotChains().

◆ _dag_

template<GUM_Numeric GUM_SCALAR>

DAG gum::prm::PRMClass< GUM_SCALAR >::_dag_

private

The dag representing dependencies between formal attributes and slots.

Definition at line 347 of file PRMClass.h.

Referenced by PRMClass(), PRMClass(), _addCastDescendants_(), _addCastDescendants_(), _checkInterface_(), _checkRefInterface_(), _implementInterfaces_(), _overloadAttribute_(), add(), addArc(), dag_(), dag_(), inheritAggregates(), inheritAttributes(), inheritParameters(), inheritReferenceSlots(), and inheritSlotChains().

◆ _dummy_hashfunc_

template<GUM_Numeric GUM_SCALAR>

HashFunc< PRMClassElementContainer< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_dummy_hashfunc_

private

a dummy member used to fix a compilation issue in clang4

Definition at line 410 of file PRMClass.h.

◆ _extensions_

template<GUM_Numeric GUM_SCALAR>

Set< PRMClass< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_extensions_

private

The set of Class<GUM_SCALAR> which are extension of this Class<GUM_SCALAR> (i.e. direct subtypes).

Definition at line 402 of file PRMClass.h.

Referenced by _addExtension_(), extensions(), and findAllSubtypes_().

◆ _implements_

template<GUM_Numeric GUM_SCALAR>

Set< PRMInterface< GUM_SCALAR >* >* gum::prm::PRMClass< GUM_SCALAR >::_implements_

private

The Set of implemented interface of this.

Definition at line 398 of file PRMClass.h.

Referenced by PRMClass(), PRMClass(), PRMClass(), PRMClass(), ~PRMClass(), _addCastDescendants_(), _addIOInterfaceFlags_(), _checkInterfaces_(), _checkRefInterfaces_(), _implementInterfaces_(), _inheritClass_(), implements(), initializeInheritance(), isOutputNode(), and isSubTypeOf().

◆ _IOFlags_

template<GUM_Numeric GUM_SCALAR>

HashTable< std::string, std::pair< bool, bool > > gum::prm::PRMClassElementContainer< GUM_SCALAR >::_IOFlags_

privateinherited

input / output flags, useful when inheriting or copying.

Definition at line 451 of file PRMClassElementContainer.h.

Referenced by copyIOFlags_(), getIOFlag_(), getIOFlag_(), isInnerNode(), isInputNode(), setInputNode(), setIOFlag_(), and setOutputNode().

◆ _name_

std::string gum::prm::PRMObject::_name_

privateinherited

Definition at line 193 of file PRMObject.h.

Referenced by PRMObject(), PRMObject(), PRMObject(), name(), name(), operator!=(), operator=(), and operator==().

◆ _nameMap_

template<GUM_Numeric GUM_SCALAR>

HashTable< std::string, PRMClassElement< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_nameMap_

private

Mapping between a member's name and itself. Used for fast access to a member given it's name.

Definition at line 361 of file PRMClass.h.

Referenced by _addCastDescendants_(), _addCastDescendants_(), _inheritClass_(), _overloadAggregate_(), _overloadAttribute_(), _overloadParameter_(), _overloadReference_(), add(), addArc(), get(), get(), inheritAggregates(), inheritAttributes(), inheritParameters(), inheritReferenceSlots(), inheritSlotChains(), and overload().

◆ _nodeIdMap_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< PRMClassElement< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_nodeIdMap_

private

Mapping between node's id and their name (being an attribute or a slot). Used for fast access to a member given it's node id.

Definition at line 351 of file PRMClass.h.

Referenced by ~PRMClass(), _addCastDescendants_(), _addCastDescendants_(), _checkInterface_(), _checkRefInterface_(), _inheritClass_(), _overloadAttribute_(), _overloadParameter_(), _overloadReference_(), add(), get(), get(), inheritAggregates(), inheritAttributes(), inheritParameters(), inheritReferenceSlots(), and inheritSlotChains().

◆ _parameters_

template<GUM_Numeric GUM_SCALAR>

Set< PRMParameter< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_parameters_

private

The Set of parameters in this Class<GUM_SCALAR>.

Definition at line 376 of file PRMClass.h.

Referenced by _inheritClass_(), _overloadParameter_(), add(), inheritParameters(), and parameters().

◆ _referenceSlots_

template<GUM_Numeric GUM_SCALAR>

Set< PRMReferenceSlot< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_referenceSlots_

private

The sequence of PRMReferenceSlot<GUM_SCALAR>.

Definition at line 367 of file PRMClass.h.

Referenced by _inheritClass_(), _overloadReference_(), add(), inheritReferenceSlots(), and referenceSlots().

◆ _slotChains_

template<GUM_Numeric GUM_SCALAR>

Set< PRMSlotChain< GUM_SCALAR >* > gum::prm::PRMClass< GUM_SCALAR >::_slotChains_

private

The set of gum::PRMSlotChain<GUM_SCALAR>s.

Definition at line 373 of file PRMClass.h.

Referenced by _inheritClass_(), _overloadReference_(), add(), inheritSlotChains(), and slotChains().

◆ _superClass_

template<GUM_Numeric GUM_SCALAR>

PRMClass< GUM_SCALAR >* gum::prm::PRMClass< GUM_SCALAR >::_superClass_

private

The alternate PRMClassElementContainer<GUM_SCALAR> searched for elements defined in this. Note that this is first searched for gum::PRMClassElement<GUM_SCALAR>.

Definition at line 395 of file PRMClass.h.

Referenced by PRMClass(), PRMClass(), PRMClass(), PRMClass(), _implementInterfaces_(), _inheritClass_(), completeInheritance(), inheritAggregates(), inheritAttributes(), inheritParameters(), inheritReferenceSlots(), inheritSlotChains(), initializeInheritance(), isOutputNode(), isSubTypeOf(), overload(), and super().

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

agrum/PRM/elements/PRMClass.h
agrum/PRM/elements/PRMClass_tpl.h

Public Member Functions

Protected Member Functions

Private Attributes

Friends

PRMClassElement<GUM_SCALAR> members

Inheritance members

Built-in types.

Detailed Description

Member Enumeration Documentation

◆ prm_type

Constructor & Destructor Documentation

◆ PRMClass() [1/6]

◆ PRMClass() [2/6]

◆ PRMClass() [3/6]

◆ PRMClass() [4/6]

◆ PRMClass() [5/6]

◆ PRMClass() [6/6]

◆ ~PRMClass()

Member Function Documentation

◆ _addCastDescendants_() [1/2]

◆ _addCastDescendants_() [2/2]

◆ _addExtension_()

◆ _addIOInterfaceFlags_()

◆ _checkInterface_()

◆ _checkInterfaces_()

◆ _checkOverloadLegality_()

◆ _checkRefInterface_()

◆ _checkRefInterfaces_()

◆ _implementInterfaces_()

◆ _inheritClass_()

◆ _overloadAggregate_()

◆ _overloadAttribute_()

◆ _overloadParameter_()

◆ _overloadReference_()

◆ add()

◆ addArc()

◆ aggregates()

◆ attributes()

◆ belongsTo()

◆ completeInheritance()

◆ containerDag()

◆ copyIOFlags_()

◆ dag_() [1/2]

◆ dag_() [2/2]

◆ enum2str()

◆ exists() [1/2]

◆ exists() [2/2]

◆ extensions()

◆ findAllSubtypes_()

◆ get() [1/4]

◆ get() [2/4]

◆ get() [3/4]

◆ get() [4/4]

◆ getIOFlag_() [1/2]

◆ getIOFlag_() [2/2]

◆ implements()

◆ inheritAggregates()

◆ inheritAttributes()

◆ inheritParameters()

◆ inheritReferenceSlots()

◆ inheritSlotChains()

◆ initializeInheritance()

◆ isCastDescendant()

◆ isClass()

◆ isInnerNode()

◆ isInputNode()

◆ isInstance()

◆ isInterface()

◆ isOutputNode()

◆ isSubTypeOf()

◆ isSuperTypeOf()

◆ LEFT_CAST()

◆ name() [1/2]

◆ name() [2/2]

◆ obj_type()

◆ operator!=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator[]() [1/4]