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 (const std::string &name)
	Default constructor. More...

	PRMClass (const std::string &name, PRMClass< GUM_SCALAR > &super, bool delayInheritance=false)
	Constructor for building a subclass of super. More...

	PRMClass (const std::string &name, const Set< PRMInterface< GUM_SCALAR > * > &set, bool delayInheritance=false)
	Constructor for building a Class<GUM_SCALAR> implementing several each interface in set. More...

	PRMClass (const std::string &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. More...

	PRMClass (const PRMClass< GUM_SCALAR > &source)=delete
	Copy constructor. More...

	PRMClass (const PRMClass< GUM_SCALAR > &&source)=delete
	Move constructor. More...

PRMClass< GUM_SCALAR > &	operator= (const PRMClass< GUM_SCALAR > &source)=delete
	Copy operator. Don't use it. More...

PRMClass< GUM_SCALAR > &	operator= (const PRMClass< GUM_SCALAR > &&source)=delete
	Move operator. Don't use it. More...

virtual	~PRMClass ()
	Destructor. More...

virtual PRMObject::prm_type	obj_type () const
	Implementation of pure virtual method of PRMObject. More...

Graphical operator
PRMClassElement< GUM_SCALAR > &	get (NodeId id)
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId). More...

const PRMClassElement< GUM_SCALAR > &	get (NodeId id) const
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::get(NodeId). More...

PRMClassElement<GUM_SCALAR> getters and setters
virtual bool	isOutputNode (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if elt is an output node. More...

bool	isCastDescendant (const std::string &safe_name) const
	Return true if the attribute named safe_name is a cast descendant. More...

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

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

virtual NodeId	add (PRMClassElement< GUM_SCALAR > *elt)
	See gum::prm::add(PRMClassElement<GUM_SCALAR>*). More...

virtual NodeId	overload (PRMClassElement< GUM_SCALAR > *elt)
	See gum::prm::overload(PRMClassElement<GUM_SCALAR>*). More...

virtual void	addArc (const std::string &tail, const std::string &head)
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::addArc(). More...

const Set< PRMAttribute< GUM_SCALAR > *> &	attributes () const
	Returns the set of PRMAttribute<GUM_SCALAR> of this Class<GUM_SCALAR>. More...

const Set< PRMParameter< GUM_SCALAR > *> &	parameters () const
	Returns the set of parameters of this Class<GUM_SCALAR>. More...

HashTable< std::string, const PRMParameter< GUM_SCALAR > *>	scope () const
	Returns all the parameters in the scope of this class. More...

const Set< PRMAggregate< GUM_SCALAR > *> &	aggregates () const
	Returns the set of PRMAggregate<GUM_SCALAR> of this Class<GUM_SCALAR>. More...

const Set< PRMReferenceSlot< GUM_SCALAR > *> &	referenceSlots () const
	Returns the set of PRMReferenceSlot<GUM_SCALAR> of this Class<GUM_SCALAR>. More...

const Set< PRMSlotChain< GUM_SCALAR > *> &	slotChains () const
	Returns the set of PRMSlotChain<GUM_SCALAR> of this Class<GUM_SCALAR>. More...

Inheritance methods
virtual bool	isSubTypeOf (const PRMClassElementContainer< GUM_SCALAR > &cec) const
	Test if this Class<GUM_SCALAR> is a subclass of cec. More...

const PRMClass< GUM_SCALAR > &	super () const
	Returns the super Class<GUM_SCALAR> of this Class<GUM_SCALAR>. More...

const Set< PRMInterface< GUM_SCALAR > *> &	implements () const
	Returns the Set of PRMInterface<GUM_SCALAR> implemented by this Class<GUM_SCALAR>. More...

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>. More...

Getters & setters operators
PRMClassElement< GUM_SCALAR > &	operator[] (NodeId id)
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId). More...

const PRMClassElement< GUM_SCALAR > &	operator[] (NodeId id) const
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>::operator[](NodeId). More...

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

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

For custom inheritance
void	inheritReferenceSlots ()

void	inheritParameters ()

void	inheritAttributes ()

void	inheritAggregates ()

void	inheritSlotChains ()

void	initializeInheritance ()

void	completeInheritance (const std::string &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. More...

virtual bool	exists (const std::string &name) const
	Returns true if a member with the given name exists in this PRMClassElementContainer or in the PRMClassElementContainer hierarchy. More...

virtual bool	isInputNode (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if the node is an input node. More...

virtual void	setInputNode (const PRMClassElement< GUM_SCALAR > &elt, bool b)
	Set the input flag value of id at b. More...

virtual void	setOutputNode (const PRMClassElement< GUM_SCALAR > &elt, bool b)
	Set the output flag value of id at b. More...

virtual bool	isInnerNode (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns true if the node is an inner node. More...

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. More...

virtual const DAG &	containerDag () const
	Returns the gum::DAG of this PRMClassElementContainer. More...

Inheritance getters and setters
virtual bool	isSuperTypeOf (const PRMClassElementContainer< GUM_SCALAR > &cec) const
	Test if this PRMClassElementContainer is a super type of cec. More...

Getters & setters.
const std::string &	name () const
	Returns the name of this object. More...

void	name (const std::string &name)
	Change the name of the PRM Object. More...

Operators
bool	operator== (const PRMObject &obj) const
	To PRMObject are equal if they have the same name (which is unique). More...

bool	operator!= (const PRMObject &obj) const
	To PRMObject are equal if they have the same name (which is unique). More...

Protected Member Functions
virtual const DAG &	_dag () const
	returns a constant reference over this interface's dag. More...

virtual DAG &	_dag ()
	Returns a non constant reference over this PRMInterface<GUM_SCALAR>'s DAG. More...

void	_findAllSubtypes (Set< PRMClassElementContainer< GUM_SCALAR > * > &set)
	Fills set with all the subtypes of this Class<GUM_SCALAR>. More...

void	_updateDescendants (const PRMClassElement< GUM_SCALAR > &elt)
	See gum::prm::PRMClassElementContainer<GUM_SCALAR>(const PRMClassElement<GUM_SCALAR>&). More...

virtual std::pair< bool, bool > &	_getIOFlag (const PRMClassElement< GUM_SCALAR > &elt)
	Returns the IO flags of a PRMClassElement<GUM_SCALAR>. More...

virtual const std::pair< bool, bool > &	_getIOFlag (const PRMClassElement< GUM_SCALAR > &elt) const
	Returns the IO flags of a PRMClassElement<GUM_SCALAR>. More...

virtual void	_setIOFlag (const PRMClassElement< GUM_SCALAR > &elt, const std::pair< bool, bool > &flags)
	Defines the IO flags of a PRMClassElement<GUM_SCALAR>. More...

virtual void	_copyIOFlags (const PRMClassElementContainer< GUM_SCALAR > &c)
	Copy the IO Flags of c in this PRMClassElementContainer. More...

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. More...

Set< PRMAttribute< GUM_SCALAR > *>	__attributes
	The sequence of PRMAttribute<GUM_SCALAR>s. More...

Set< PRMReferenceSlot< GUM_SCALAR > *>	__referenceSlots
	The sequence of PRMReferenceSlot<GUM_SCALAR>. More...

Set< PRMAggregate< GUM_SCALAR > *>	__aggregates
	The sequence of aggregate. More...

Set< PRMSlotChain< GUM_SCALAR > *>	__slotChains
	The set of gum::PRMSlotChain<GUM_SCALAR>s. More...

Set< PRMParameter< GUM_SCALAR > *>	__parameters
	The Set of parameters in this Class<GUM_SCALAR>. More...

void	__addCastDescendants (PRMClassElement< GUM_SCALAR > *attr)
	Recursively adds cast descendant of attr in this Class<GUM_SCALAR>. More...

void	__addCastDescendants (PRMAttribute< GUM_SCALAR > start, PRMAttribute< GUM_SCALAR > end)
	Recursively adds cast descendant from start to end in this Class<GUM_SCALAR>. More...

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>. More...

Set< PRMInterface< GUM_SCALAR > >	__implements
	The Set of implemented interface of this. More...

Set< PRMClass< GUM_SCALAR > *>	__extensions
	The set of Class<GUM_SCALAR> which are extension of this Class<GUM_SCALAR> (i.e. direct subtypes). More...

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. More...

HashFunc< PRMClassElementContainer< GUM_SCALAR > *>	__dummy_hashfunc
	a dummy member used to fix a compilation issue in clang4 More...

void	__inheritClass (const PRMClass< GUM_SCALAR > &c)
	Proceed with the copy when this inherits c. More...

void	__implementInterfaces (bool delayInheritance)
	Proceed with the implementation of interfaces. More...

void	__checkInterfaces (PRMClassElement< GUM_SCALAR > *elt)
	Check that a given element respects all the class interfaces. More...

void	__checkInterface (PRMClassElement< GUM_SCALAR > elt, PRMInterface< GUM_SCALAR > i)
	Check that a given element respects a specific interface. More...

void	__checkRefInterfaces (PRMReferenceSlot< GUM_SCALAR > *elt)
	Check that a given element respects all the class interfaces. More...

void	__checkRefInterface (PRMReferenceSlot< GUM_SCALAR > elt, PRMInterface< GUM_SCALAR > i)
	Check that a given element respects a specific interface. More...

void	__addIOInterfaceFlags (PRMClassElement< GUM_SCALAR > *elt)
	Check if elt is present in an implementation. If it is, its IO flags are updated. More...

void	__addExtension (PRMClass< GUM_SCALAR > *c)
	This method is called when a sub-Class<GUM_SCALAR> of this Class<GUM_SCALAR> is created. More...

bool	__checkOverloadLegality (const PRMClassElement< GUM_SCALAR > overloaded, const PRMClassElement< GUM_SCALAR > overloader)
	Return true of overloaded can be overload by overloader. More...

void	__overloadAttribute (PRMAttribute< GUM_SCALAR > overloader, PRMAttribute< GUM_SCALAR > overloaded)
	Overloads an attribute. More...

void	__overloadAggregate (PRMAggregate< GUM_SCALAR > overloader, PRMClassElement< GUM_SCALAR > overloaded)
	Overloads an aggregate. More...

void	__overloadReference (PRMReferenceSlot< GUM_SCALAR > overloader, PRMReferenceSlot< GUM_SCALAR > overloaded)
	Overloads a reference slot. More...

void	__overloadParameter (PRMParameter< GUM_SCALAR > overloader, PRMParameter< GUM_SCALAR > overloaded)
	Overloads a parameter. More...

Built-in types.
enum	prm_type : char { prm_type::ALL, prm_type::CLASS, prm_type::PRM_INTERFACE, prm_type::CLASS_ELT, prm_type::TYPE, prm_type::SYSTEM, prm_type::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. More...

static std::string	RIGHT_CAST ()
	Enumeration of the different types of objects handled by a PRM. More...

static std::string	enum2str (prm_type type)
	Returns the string representation of a PRMObject. More...

static INLINE bool	isClass (const PRMObject &obj)
	Returns true if obj_ptr is of type Class. More...

static INLINE bool	isInterface (const PRMObject &obj)
	Returns true if obj_ptr is of type PRMInterface. More...

static INLINE bool	isInstance (const PRMObject &obj)
	Returns true if obj_ptr is of type PRMInstance. More...

Detailed Description

template<typename 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 63 of file PRMClass.h.

Member Enumeration Documentation

◆ prm_type

enum 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 66 of file PRMObject.h.

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

Constructor & Destructor Documentation

◆ PRMClass() [1/6]

template<typename GUM_SCALAR >

gum::prm::PRMClass< GUM_SCALAR >::PRMClass ( const std::string & name )

explicit

Default constructor.

Parameters

name	The class name.

Definition at line 37 of file PRMClass_tpl.h.

                                                           :
         PRMClassElementContainer< GUM_SCALAR >(name), __superClass(nullptr),
         __implements(nullptr), __bijection(nullptr) {
       GUM_CONSTRUCTOR(PRMClass);
     }

◆ PRMClass() [2/6]

template<typename GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	const std::string &	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 44 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);
       }
     }

◆ PRMClass() [3/6]

template<typename GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	const std::string &	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 59 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); }
     }

◆ PRMClass() [4/6]

template<typename GUM_SCALAR>

gum::prm::PRMClass< GUM_SCALAR >::PRMClass	(	const std::string &	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 72 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); }
     }

◆ PRMClass() [5/6]

template<typename GUM_SCALAR>

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

delete

Copy constructor.

◆ PRMClass() [6/6]

template<typename GUM_SCALAR>

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

delete

Move constructor.

◆ ~PRMClass()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 117 of file PRMClass_tpl.h.

                                       {
       GUM_DESTRUCTOR(PRMClass);
 
       for (const auto& elt : __nodeIdMap) {
         delete elt.second;
       }
 
       if (__implements) { delete __implements; }
 
       if (__bijection) { delete __bijection; }
     }

Member Function Documentation

◆ __addCastDescendants() [1/2]

template<typename 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 692 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;
         try {
           for (auto i : implements()) {
             if (i->exists(child->safeName())) {
               child->setId(i->get(child->safeName()).id());
               found = true;
               break;
             }
           }
         } catch (NotFound&) {
           // No interface
         }
         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;
       }
     }

◆ __addCastDescendants() [2/2]

template<typename 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 940 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());
     }

◆ __addExtension()

template<typename GUM_SCALAR>

INLINE 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 1256 of file PRMClass_tpl.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass(), and gum::prm::PRMClass< double >::initializeInheritance().

                                                                                 {
       __extensions.insert(c);
     }

Here is the caller graph for this function:

◆ __addIOInterfaceFlags()

template<typename 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 974 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&) {
                 this->_setIOFlag(*elt, std::make_pair(false, true));
               }
             }
             try {
               super = &(super->super());
             } catch (NotFound&) { super = nullptr; }
           }
         }
       }
     }

◆ __checkInterface()

template<typename 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 539 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);
     }

◆ __checkInterfaces()

template<typename 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 526 of file PRMClass_tpl.h.

                                            {
       try {
         for (auto i : implements()) {
           if (i->exists(elt->name())) { __checkInterface(elt, i); }
         }
       } catch (NotFound&) {
         // No interface
       }
     }

◆ __checkOverloadLegality()

template<typename GUM_SCALAR>

INLINE 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 1208 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;
     }

◆ __checkRefInterface()

template<typename 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 593 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);
     }

◆ __checkRefInterfaces()

template<typename 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 581 of file PRMClass_tpl.h.

                                             {
       try {
         for (auto i : implements()) {
           if (i->exists(ref->name())) { __checkRefInterface(ref, i); }
         }
       } catch (NotFound&) {
         // No interface to check
       }
     }

◆ __implementInterfaces()

template<typename GUM_SCALAR >

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

private

Proceed with the implementation of interfaces.

Definition at line 99 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());
           }
         }
       }
     }

◆ __inheritClass()

template<typename 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 312 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 potentials 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&) {
             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);
         }
       }
     }

◆ __overloadAggregate()

template<typename GUM_SCALAR>

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

private

Overloads an aggregate.

Definition at line 1200 of file PRMClass_tpl.h.

                                                   {
       __nameMap.insert(overloader->safeName(), overloader);
       __aggregates.insert(overloader);
     }

◆ __overloadAttribute()

template<typename GUM_SCALAR>

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

private

Overloads an attribute.

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

◆ __overloadParameter()

template<typename GUM_SCALAR>

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

private

Overloads a parameter.

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

◆ __overloadReference()

template<typename 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 831 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;
     }

◆ _copyIOFlags()

template<typename 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 34 of file PRMClassElementContainer_tpl.h.

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

◆ _dag() [1/2]

template<typename GUM_SCALAR >

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

protectedvirtual

returns a constant reference over this interface's dag.

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

Definition at line 1015 of file PRMClass_tpl.h.

                                                          {
       return __dag;
     }

◆ _dag() [2/2]

template<typename GUM_SCALAR >

INLINE DAG & gum::prm::PRMClass< GUM_SCALAR >::_dag ( )

protectedvirtual

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

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

Definition at line 1020 of file PRMClass_tpl.h.

                                              {
       return __dag;
     }

◆ _findAllSubtypes()

template<typename GUM_SCALAR>

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

protectedvirtual

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

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

Definition at line 965 of file PRMClass_tpl.h.

Referenced by gum::prm::PRMClass< double >::_findAllSubtypes().

                                                             {
       for (auto ext : __extensions) {
         set.insert(ext);
         ext->_findAllSubtypes(set);
       }
     }

Here is the caller graph for this function:

◆ _getIOFlag() [1/2]

template<typename GUM_SCALAR>

INLINE 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 128 of file PRMClassElementContainer_tpl.h.

                                                     {
       try {
         return __IOFlags[elt.safeName()];
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "this ClassElement<GUM_SCALAR> does not have any IO flags");
       }
     }

◆ _getIOFlag() [2/2]

template<typename GUM_SCALAR>

INLINE 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 140 of file PRMClassElementContainer_tpl.h.

                                                           {
       try {
         return __IOFlags[elt.safeName()];
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "this ClassElement<GUM_SCALAR> does not have any IO flags");
       }
     }

◆ _setIOFlag()

template<typename GUM_SCALAR>

INLINE 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 151 of file PRMClassElementContainer_tpl.h.

                                                  {
       try {
         __IOFlags[elt.safeName()] = flags;
       } catch (NotFound&) { __IOFlags.insert(elt.safeName(), flags); }
     }

◆ _updateDescendants()

template<typename GUM_SCALAR>

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

protectedvirtual

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

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

Definition at line 999 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 );
       //  }
       //}
     }

◆ add()

template<typename GUM_SCALAR>

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

virtual

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

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

Definition at line 618 of file PRMClass_tpl.h.

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().

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

Here is the caller graph for this function:

◆ addArc()

template<typename GUM_SCALAR >

void gum::prm::PRMClass< GUM_SCALAR >::addArc	(	const std::string &	tail,
		const std::string &	head
	)

virtual

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

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

Definition at line 480 of file PRMClass_tpl.h.

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

                                                                     {
       PRMClassElement< GUM_SCALAR >* tail = 0;
       PRMClassElement< GUM_SCALAR >* head = 0;
 
       try {
         tail = __nameMap[tail_name];
         head = __nameMap[head_name];
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "tail and/or head of arc does not exists in this Class");
       }
 
       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);
       }
     }

Here is the caller graph for this function:

◆ aggregates()

template<typename GUM_SCALAR >

INLINE 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 1139 of file PRMClass_tpl.h.

                                                           {
       return __aggregates;
     }

◆ attributes()

template<typename GUM_SCALAR >

INLINE 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 1071 of file PRMClass_tpl.h.

                                                           {
       return __attributes;
     }

◆ belongsTo()

template<typename GUM_SCALAR>

INLINE 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 174 of file PRMClassElementContainer_tpl.h.

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

◆ completeInheritance()

template<typename GUM_SCALAR >

void gum::prm::PRMClass< GUM_SCALAR >::completeInheritance ( const std::string & attr )

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

◆ containerDag()

template<typename GUM_SCALAR >

INLINE 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 183 of file PRMClassElementContainer_tpl.h.

Referenced by gum::prm::ClassDependencyGraph< GUM_SCALAR >::__addArcs(), gum::prm::PRMClass< double >::__inheritClass(), gum::prm::ClassBayesNet< GUM_SCALAR >::__init(), gum::prm::SVED< GUM_SCALAR >::__initLiftedNodes(), gum::prm::SVE< GUM_SCALAR >::__initLiftedNodes(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), operator<<(), and gum::prm::PRMClass< double >::PRMClass().

                                                                             {
       return _dag();
     }

Here is the caller graph for this function:

◆ enum2str()

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

inlinestaticinherited

Returns the string representation of a PRMObject.

Definition at line 80 of file PRMObject.h.

References gum::prm::PRMObject::CLASS, gum::prm::PRMObject::CLASS_ELT, gum::prm::PRMObject::INSTANCE, gum::prm::PRMObject::PRM_INTERFACE, gum::prm::PRMObject::SYSTEM, and gum::prm::PRMObject::TYPE.

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

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

Here is the caller graph for this function:

◆ exists() [1/2]

template<typename GUM_SCALAR >

INLINE bool gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists ( const std::string & name ) const

virtualinherited

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

Definition at line 165 of file PRMClassElementContainer_tpl.h.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__checkLocalParent(), gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::__checkParameters(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__checkSlotChainLink(), gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound(), gum::prm::PRMFactory< GUM_SCALAR >::continueAggregator(), gum::prm::PRMFactory< GUM_SCALAR >::continueAttribute(), gum::prm::PRMClassElementContainer< double >::exists(), and gum::prm::PRMFactory< GUM_SCALAR >::startAttribute().

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

Here is the caller graph for this function:

◆ exists() [2/2]

template<typename GUM_SCALAR >

INLINE 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 160 of file PRMClassElementContainer_tpl.h.

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

◆ extensions()

template<typename GUM_SCALAR >

INLINE 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 1251 of file PRMClass_tpl.h.

                                                           {
       return __extensions;
     }

◆ get() [1/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1025 of file PRMClass_tpl.h.

Referenced by 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::SVED< GUM_SCALAR >::__initLiftedNodes(), gum::prm::SVE< GUM_SCALAR >::__initLiftedNodes(), gum::prm::PRMFactory< GUM_SCALAR >::__retrieveInputs(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), and gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound().

                                                                                {
       try {
         return *(__nodeIdMap[id]);
       } catch (NotFound&) {
         GUM_ERROR(NotFound, "no ClassElement<GUM_SCALAR> with the given NodeId");
       }
     }

Here is the caller graph for this function:

◆ get() [2/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1035 of file PRMClass_tpl.h.

                                                             {
       try {
         return *(__nodeIdMap[id]);
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "no ClassElement<GUM_SCALAR> with the given NodeId (" << id
                                                                         << ")");
       }
     }

◆ get() [3/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1047 of file PRMClass_tpl.h.

                                                             {
       try {
         return *(__nameMap[name]);
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "no ClassElement<GUM_SCALAR> with the given name (" << name
                                                                       << ")");
       }
     }

◆ get() [4/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1059 of file PRMClass_tpl.h.

                                                                         {
       try {
         return *(__nameMap[name]);
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   "no ClassElement<GUM_SCALAR> with the given name (" << name
                                                                       << ")");
       }
     }

◆ implements()

template<typename GUM_SCALAR >

INLINE 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 1166 of file PRMClass_tpl.h.

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

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

Here is the caller graph for this function:

◆ inheritAggregates()

template<typename GUM_SCALAR >

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

Definition at line 223 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&) {
             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);
         }
       }
     }

◆ inheritAttributes()

template<typename GUM_SCALAR >

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

Definition at line 194 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 potentials 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);
         }
       }
     }

◆ inheritParameters()

template<typename GUM_SCALAR >

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

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

◆ inheritReferenceSlots()

template<typename GUM_SCALAR >

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

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

◆ inheritSlotChains()

template<typename GUM_SCALAR >

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

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

◆ initializeInheritance()

template<typename GUM_SCALAR >

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

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

◆ isCastDescendant()

template<typename GUM_SCALAR >

INLINE bool gum::prm::PRMClass< GUM_SCALAR >::isCastDescendant ( const std::string & 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 1261 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&) {
         GUM_ERROR(NotFound, "no attribute with the given name");
       }
     }

◆ isClass()

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

inlinestaticinherited

Returns true if obj_ptr is of type Class.

Definition at line 99 of file PRMObject.h.

References gum::prm::PRMObject::CLASS, and gum::prm::PRMObject::obj_type().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isInnerNode()

template<typename GUM_SCALAR>

INLINE 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 113 of file PRMClassElementContainer_tpl.h.

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

                                                        {
       try {
         return !(_getIOFlag(elt).first || _getIOFlag(elt).second);
       } catch (NotFound&) { return true; }
     }

Here is the caller graph for this function:

◆ isInputNode()

template<typename GUM_SCALAR>

INLINE 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 69 of file PRMClassElementContainer_tpl.h.

                                                        {
       try {
         return _getIOFlag(elt).first;
       } catch (NotFound&) { return false; }
     }

◆ isInstance()

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

inlinestaticinherited

Returns true if obj_ptr is of type PRMInstance.

Definition at line 109 of file PRMObject.h.

References gum::prm::PRMObject::INSTANCE, gum::prm::PRMObject::name(), gum::prm::PRMObject::obj_type(), gum::prm::PRMObject::operator!=(), gum::prm::PRMObject::operator=(), gum::prm::PRMObject::operator==(), gum::prm::PRMObject::PRMObject(), and gum::prm::PRMObject::~PRMObject().

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

Here is the call graph for this function:

◆ isInterface()

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

inlinestaticinherited

Returns true if obj_ptr is of type PRMInterface.

Definition at line 104 of file PRMObject.h.

References gum::prm::PRMObject::obj_type(), and gum::prm::PRMObject::PRM_INTERFACE.

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

Here is the call graph for this function:

◆ isOutputNode()

template<typename GUM_SCALAR>

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

virtual

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 1273 of file PRMClass_tpl.h.

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

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

Here is the caller graph for this function:

◆ isSubTypeOf()

template<typename GUM_SCALAR>

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

virtual

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

◆ isSuperTypeOf()

template<typename GUM_SCALAR>

INLINE 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 121 of file PRMClassElementContainer_tpl.h.

                                                                 {
       return cec.isSubTypeOf(*this);
     }

◆ LEFT_CAST()

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

inlinestaticinherited

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 76 of file PRMObject.h.

Referenced by gum::prm::decomposePath(), gum::prm::PRMFormAttribute< GUM_SCALAR >::PRMFormAttribute(), and gum::prm::PRMScalarAttribute< GUM_SCALAR >::PRMScalarAttribute().

76 { return "("; }

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 32 of file PRMObject_inl.h.

References gum::prm::PRMObject::__name.

32 { return __name; }

gum::prm::PRMObject::__name

std::string __name

Definition: PRMObject.h:197

◆ name() [2/2]

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

inherited

Change the name of the PRM Object.

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

Definition at line 36 of file PRMObject_inl.h.

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

36 { __name = name; }

gum::prm::PRMObject::name

const std::string & name() const

Returns the name of this object.

Definition: PRMObject_inl.h:32

gum::prm::PRMObject::__name

std::string __name

Definition: PRMObject.h:197

Here is the call graph for this function:

◆ obj_type()

template<typename GUM_SCALAR >

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

virtual

Implementation of pure virtual method of PRMObject.

Implements gum::prm::PRMObject.

Definition at line 1010 of file PRMClass_tpl.h.

                                                                              {
       return PRMObject::prm_type::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 46 of file PRMObject_inl.h.

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

Referenced by gum::prm::PRMObject::isInstance().

                                                          {
       return __name != obj.name();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

template<typename GUM_SCALAR>

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

delete

Copy operator. Don't use it.

◆ operator=() [2/2]

template<typename GUM_SCALAR>

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

delete

Move operator. Don't use it.

◆ 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 40 of file PRMObject_inl.h.

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

Referenced by gum::prm::PRMObject::isInstance().

                                                          {
       return __name == obj.name();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator[]() [1/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1177 of file PRMClass_tpl.h.

                                                                 {
       return get(id);
     }

◆ operator[]() [2/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1183 of file PRMClass_tpl.h.

                                                                             {
       return get(id);
     }

◆ operator[]() [3/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1189 of file PRMClass_tpl.h.

                                                                             {
       return get(name);
     }

◆ operator[]() [4/4]

template<typename GUM_SCALAR >

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

virtual

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

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

Definition at line 1195 of file PRMClass_tpl.h.

                                                                                         {
       return get(name);
     }

◆ overload()

template<typename GUM_SCALAR>

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

virtual

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

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

Definition at line 730 of file PRMClass_tpl.h.

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

                                                   {
       try {
         if (!super().exists(overloader->name())) {
           GUM_ERROR(OperationNotAllowed,
                     "found no ClassElement<GUM_SCALAR> to overload");
         }
       } catch (NotFound&) {
         GUM_ERROR(OperationNotAllowed,
                   "overload is possible only with subclasses");
       }
 
       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();
     }

Here is the caller graph for this function:

◆ parameters()

template<typename GUM_SCALAR >

INLINE 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 1077 of file PRMClass_tpl.h.

                                                           {
       return __parameters;
     }

◆ referenceSlots()

template<typename GUM_SCALAR >

INLINE 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 1145 of file PRMClass_tpl.h.

                                                               {
       return __referenceSlots;
     }

◆ RIGHT_CAST()

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

inlinestaticinherited

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 77 of file PRMObject.h.

Referenced by gum::prm::decomposePath(), gum::prm::PRMFormAttribute< GUM_SCALAR >::PRMFormAttribute(), and gum::prm::PRMScalarAttribute< GUM_SCALAR >::PRMScalarAttribute().

77 { return ")"; }

Here is the caller graph for this function:

◆ scope()

template<typename GUM_SCALAR >

INLINE 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 1098 of file PRMClass_tpl.h.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__checkRawCPT(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__checkRuleCPT().

                                                {
       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_TRACE("Depth limit reached when looking up parameters");
         }
       }
 
       return params;
     }

Here is the caller graph for this function:

◆ setInputNode()

template<typename GUM_SCALAR>

INLINE 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 77 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)) {
         try {
           _getIOFlag(elt).first = b;
         } catch (NotFound&) { _setIOFlag(elt, std::make_pair(b, false)); }
       } else {
         GUM_ERROR(WrongClassElement,
                   "given id is not an PRMAttribute or an PRMAggregate");
       }
     }

◆ setOutputNode()

template<typename GUM_SCALAR>

INLINE 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 94 of file PRMClassElementContainer_tpl.h.

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

                                                          {
       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)) {
         try {
           _getIOFlag(elt).second = b;
         } catch (NotFound&) { _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");
       }
     }

Here is the caller graph for this function:

◆ slotChains()

template<typename GUM_SCALAR >

INLINE 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 1151 of file PRMClass_tpl.h.

                                                           {
       return __slotChains;
     }

◆ super()

template<typename GUM_SCALAR >

INLINE 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 1156 of file PRMClass_tpl.h.

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

Friends And Related Function Documentation

◆ PRMInterface< GUM_SCALAR >

template<typename GUM_SCALAR>

friend class PRMInterface< GUM_SCALAR >

friend

Definition at line 64 of file PRMClass.h.

Member Data Documentation

◆ __aggregates

template<typename GUM_SCALAR>

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

private

The sequence of aggregate.

Definition at line 362 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __attributes

template<typename GUM_SCALAR>

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

private

The sequence of PRMAttribute<GUM_SCALAR>s.

Definition at line 356 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __bijection

template<typename 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 400 of file PRMClass.h.

◆ __dag

template<typename GUM_SCALAR>

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

private

The dag representing dependencies between formal attributes and slots.

Definition at line 339 of file PRMClass.h.

◆ __dummy_hashfunc

template<typename 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 403 of file PRMClass.h.

◆ __extensions

template<typename 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 395 of file PRMClass.h.

◆ __implements

template<typename GUM_SCALAR>

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

private

The Set of implemented interface of this.

Definition at line 391 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __nameMap

template<typename 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 353 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __nodeIdMap

template<typename 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 343 of file PRMClass.h.

◆ __parameters

template<typename 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 368 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __referenceSlots

template<typename GUM_SCALAR>

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

private

The sequence of PRMReferenceSlot<GUM_SCALAR>.

Definition at line 359 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __slotChains

template<typename GUM_SCALAR>

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

private

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

Definition at line 365 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::__inheritClass().

◆ __superClass

template<typename 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 388 of file PRMClass.h.

Referenced by gum::prm::PRMClass< double >::isSubTypeOf().

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

Friends

PRMClassElement<GUM_SCALAR> members

Inheritance members

Built-in types.

Detailed Description

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

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()

◆ _copyIOFlags()

◆ _dag() [1/2]

◆ _dag() [2/2]

◆ _findAllSubtypes()

◆ _getIOFlag() [1/2]

◆ _getIOFlag() [2/2]

◆ _setIOFlag()

◆ _updateDescendants()

◆ add()

◆ addArc()

◆ aggregates()

◆ attributes()

◆ belongsTo()

◆ completeInheritance()

◆ containerDag()

◆ enum2str()

◆ exists() [1/2]

◆ exists() [2/2]

◆ extensions()

◆ get() [1/4]

◆ get() [2/4]

◆ get() [3/4]

◆ get() [4/4]

◆ 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]

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