Factory which builds a PRM<GUM_SCALAR>. More...

#include <PRMFactory.h>

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

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

Public Member Functions
Constructors & destructor
	PRMFactory ()
	Default constructor.
	PRMFactory (PRM< GUM_SCALAR > *prm)
	This constructor let you set on which PRM instance the factory works.
	PRMFactory (const PRMFactory &from)=delete
	Copy constructor. Don't use it.
PRMFactory &	operator= (const PRMFactory &from)=delete
	Copy operator. Don't use it.
	~PRMFactory () override
	Destructor.
Getters & Setters
PRM< GUM_SCALAR > *	prm () const
	Returns a pointer on the PRM<GUM_SCALAR> created by this factory.
PRMObject::prm_type	currentType () const override
PRMObject *	getCurrent () override
const PRMObject *	getCurrent () const override
	Returns a pointer on the PRM<GUM_SCALAR> created by this factory.
PRMObject *	closeCurrent () override
	Close current object being built.
std::string	currentPackage () const override
PRMClass< GUM_SCALAR > &	retrieveClass (std::string_view name)
	Returns a reference over a Class<GUM_SCALAR> given its name.
PRMType &	retrieveType (std::string_view name)
	Returns a reference over a PRMType given its name.
PRMType &	retrieveCommonType (const std::vector< PRMClassElement< GUM_SCALAR > * > &elts)
	Returns a pointer on the PRM<GUM_SCALAR> created by this factory.
Package construction methods.
void	pushPackage (std::string_view name) override
	Define the current package.
std::string	popPackage () override
	Pop the current package from the package stack.
void	addImport (std::string_view name) override
	Add an import for namespace lookup.
PRMType construction methods.
void	startDiscreteType (std::string_view name, std::string_view super="") override
	Start a discrete subtype declaration.
void	addLabel (std::string_view l, std::string_view ext="") override
	Add a label to the current discrete type.
void	endDiscreteType () override
	End the current discrete type declaration.
void	startDiscretizedType (std::string_view name) override
	Start a discretized type declaration.
void	addTick (double tick) override
	Add a tick to the current discretized type.
void	endDiscretizedType () override
	End the current discretized type declaration.
void	addRangeType (std::string_view name, long minVal, long maxVal) override
	Add a range variable type declaration.
several checks for parsers
bool	isClassOrInterface (std::string_view type) const override
bool	isArrayInCurrentSystem (std::string_view name) const override
Class<GUM_SCALAR> construction models.
void	startClass (std::string_view c, std::string_view ext="", const Set< std::string > *implements=nullptr, bool delayInheritance=false) override
	Tells the factory that we start a class declaration.
void	continueClass (std::string_view c) override
	Continue the declaration of a class.
void	endClass (bool checkImplementations=true) override
	Tells the factory that we finished a class declaration.
PRMInterface<GUM_SCALAR> construction models.
void	startInterface (std::string_view i, std::string_view ext="", bool delayInheritance=false) override
	Tells the factory that we start an interface declaration.
void	continueInterface (std::string_view name) override
	Continue the declaration of an interface.
void	addAttribute (std::string_view type, std::string_view name) override
	Add an attribute to an interface.
void	endInterface () override
	Tells the factory that we finished an interface declaration.
Attributes construction methods.
virtual void	addAttribute (PRMAttribute< GUM_SCALAR > *attr)
	Add an already created attribute to the current class.
void	startAttribute (std::string_view type, std::string_view name, bool scalar_atttr=false) override
	Tells the factory that we start an attribute declaration.
void	continueAttribute (std::string_view name) override
	Continues the declaration of an attribute.
void	addParent (std::string_view name) override
	Tells the factory that we add a parent to the current declared attribute.
void	setRawCPFByLines (const std::vector< GUM_SCALAR > &array)
	Gives the factory the CPF in its raw form.
void	setRawCPFByColumns (const std::vector< GUM_SCALAR > &array)
	Gives the factory the CPF in its raw form.
virtual void	setCPFByRule (const std::vector< std::string > &labels, const std::vector< GUM_SCALAR > &values)
	Fills the CPF using a rule.
void	setCPFByRule (const std::vector< std::string > &labels, const std::vector< std::string > &values) override
	Fills the CPF using a rule and gum::Formula.
void	setRawCPFByFloatLines (const std::vector< float > &array) override
	Gives the factory the CPF in its raw form.
void	setRawCPFByFloatColumns (const std::vector< float > &array) override
	Gives the factory the CPF in its raw form.
void	setRawCPFByColumns (const std::vector< std::string > &array) override
	Gives the factory the CPF in its raw form use gum::Formula.
void	setRawCPFByLines (const std::vector< std::string > &array) override
	Gives the factory the CPF in its raw form using gum::Formula.
void	setCPFByFloatRule (const std::vector< std::string > &labels, const std::vector< float > &values) override
	Fills the CPF using a rule.
void	endAttribute () override
	Tells the factory that we finished declaring an attribute.
Parameters construction methods.
void	addParameter (std::string_view type, std::string_view name, double value) override
	Add a parameter to the current class with a default value.
Aggregator and function construction methods.
void	addAggregator (std::string_view name, std::string_view agg_type, const std::vector< std::string > &chains, const std::vector< std::string > &params, std::string_view type="") override
	Add an aggregator in the current declared class.
void	startAggregator (std::string_view name, std::string_view agg_type, std::string_view rv_type, const std::vector< std::string > &params)
	Start an aggregator declaration.
void	continueAggregator (std::string_view name)
	Conitnues an aggregator declaration.
void	endAggregator ()
	Finishes an aggregate declaration.
void	addNoisyOrCompound (std::string_view name, const std::vector< std::string > &chains, const std::vector< float > &numbers, float leak, const std::vector< std::string > &label) override
	Add a compound noisy-or as an PRMAttribute<GUM_SCALAR> to the current Class<GUM_SCALAR>.
PRMReferenceSlot<GUM_SCALAR> construction methods.
void	addReferenceSlot (std::string_view type, std::string_view name, bool isArray) override
	Tells the factory that we started declaring a slot.
Systems constructions methods.
void	startSystem (std::string_view name) override
	Tells the factory that we started declaring a model.
void	endSystem () override
	Tells the factory that we finished declaring a model.
void	addInstance (std::string_view type, std::string_view name) override
	Add an instance to the model.
void	addInstance (std::string_view type, std::string_view name, const HashTable< std::string, double > &params) override
	Add an instance with params as values of type's parameters.
void	addArray (std::string_view type, std::string_view name, Size size) override
	Creates an array with the given number of instances of the given type.
void	incArray (std::string_view l_i, std::string_view r_i) override
	Add an instance to an array.
void	setReferenceSlot (std::string_view left_instance, std::string_view left_reference, std::string_view right_instance) override
	Instantiate a reference in the current model.
void	setReferenceSlot (std::string_view l_i, std::string_view r_i) override
	Instantiate a reference in the current model.

Private Member Functions
Private methods for type checking and exception handling.
std::string	_addPrefix_ (std::string_view str) const
	Adds prefix to str iff prefix != "".
PRMObject *	_checkStack_ (Idx i, PRMObject::prm_type obj_type)
	Return a pointer on a PRMObject at stack.size() - i position after checking the type of the object given obj_type.
PRMClassElement< GUM_SCALAR > *	_checkStack_ (Idx i, typename PRMClassElement< GUM_SCALAR >::ClassElementType obj_type)
	Adds prefix to str iff prefix != "".
PRMClassElementContainer< GUM_SCALAR > *	_checkStackContainter_ (Idx i)
	Adds prefix to str iff prefix != "".
Private getters
PRMType *	_retrieveType_ (std::string_view name) const
	Returns a pointer on a PRMType given it's name. Since the type can be given either with it's local name (without the prefix), full name (with the prefix) or can come from an import unit, or maybe one day with a using declaration we need some processing to find it.
PRMClass< GUM_SCALAR > *	_retrieveClass_ (std::string_view name) const
	Returns a pointer on a class given it's name. Used when building models, meaning that the class name can either be local (need to add the current prefix) or global (no prefix needed).
PRMInterface< GUM_SCALAR > *	_retrieveInterface_ (std::string_view name) const
	Returns a pointer on an interface given it's name. Used when building models, meaning that the interface name can either be local (need to add the current prefix) or global (no prefix needed).
Private methods handling Class<GUM_SCALAR> and
PRMClassElement<GUM_SCALAR> creation.
PRMSlotChain< GUM_SCALAR > *	_buildSlotChain_ (PRMClassElementContainer< GUM_SCALAR > *start, std::string_view name)
	This methods build a PRMSlotChain<GUM_SCALAR> given a starting element and a string.
bool	_retrieveInputs_ (PRMClass< GUM_SCALAR > c, const std::vector< std::string > &chains, std::vector< PRMClassElement< GUM_SCALAR > > &inputs)
	Retrieve inputs for an PRMAggregate.
PRMType *	_retrieveCommonType_ (const std::vector< PRMClassElement< GUM_SCALAR > * > &elts)
	Retrieve the common PRMType of a vector of PRMClassElement<GUM_SCALAR>.
int	_typeDepth_ (const PRMType *t)
	Returns the inheritance depth of a PRMType.
void	_checkInterfaceImplementation_ (PRMClass< GUM_SCALAR > *c)
	Check if c implements correctly all his interfaces.
void	_addParent_ (PRMClassElementContainer< GUM_SCALAR > c, PRMAttribute< GUM_SCALAR > agg, std::string_view name)
	Add a parent to an attribute.
void	_addParent_ (PRMClass< GUM_SCALAR > c, PRMAggregate< GUM_SCALAR > agg, std::string_view name)
	Add a parent to an aggregate.
Private methods handling PRMSystem<GUM_SCALAR> and
PRMInstance<GUM_SCALAR> creation.
void	_addInstance_ (PRMClass< GUM_SCALAR > *type, std::string_view name)
	Adds an instance to the current model.
void	_buildAggregateCPF_ (PRMSystem< GUM_SCALAR > *model)
	Builds all Aggregates CPF in the given model. This must be called after all the slot chains have been generated.
void	_instantiateSlotChain_ (PRMSystem< GUM_SCALAR > model, PRMInstance< GUM_SCALAR > inst, PRMReferenceSlot< GUM_SCALAR > ref, PRMSlotChain< GUM_SCALAR > sc)
	Instantiate a slot chain in the given instance.
std::string	_retrieveInstanceSequence_ (PRMInstance< GUM_SCALAR > inst, Sequence< PRMInstance< GUM_SCALAR > > &seq, PRMSlotChain< GUM_SCALAR > *sc)
	Fill seq with the sequence of instance build using inst as the instantiation of sc-> class and seeking each instantiation of reference in sc.

Private Attributes
Private members.
std::vector< std::string >	_packages_
	The prefix used for classes and types names. It is normally the namespace of the corresponding compilation unit.
std::vector< List< std::string > * >	_namespaces_
	Set of all declared namespaces.
PRM< GUM_SCALAR > *	_prm_
	The pointer on the PRM<GUM_SCALAR> built by this factory.
std::vector< PRMObject * >	_stack_
	A stack used to keep track of created PRMObject.
HashTable< PRMAggregate< GUM_SCALAR > *, std::vector< std::string > >	_agg_params_
	A mapping between aggregators and their parameters.

Detailed Description

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

Factory which builds a PRM<GUM_SCALAR>.

The Factory always create one PRM<GUM_SCALAR> which is not deleted with the factory, so be very careful to delete the PRM<GUM_SCALAR> built by this factory.

The factory does not allow any sequence of calls, if you call a method when the factory is in an incoherent state it will raise a FactoryInvalidState exception.

Keep in mind that most methods could raise gum::FatalError if something unexpected happens, since the framework is meant to evolve it is possible.

See also: PRM<GUM_SCALAR> PRMObject

Definition at line 90 of file PRMFactory.h.

Constructor & Destructor Documentation

◆ PRMFactory() [1/3]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMFactory< GUM_SCALAR >::PRMFactory ( )

Default constructor.

Definition at line 1304 of file PRMFactory_tpl.h.

                                         {
      GUM_CONSTRUCTOR(PRMFactory);
      _prm_ = new PRM< GUM_SCALAR >();
    }

References PRMFactory(), and _prm_.

Referenced by PRMFactory(), PRMFactory(), PRMFactory(), ~PRMFactory(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PRMFactory() [2/3]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMFactory< GUM_SCALAR >::PRMFactory ( PRM< GUM_SCALAR > * prm )

This constructor let you set on which PRM instance the factory works.

Definition at line 1310 of file PRMFactory_tpl.h.

                                                               : IPRMFactory(), _prm_(prm) {
      GUM_CONSTRUCTOR(PRMFactory);
    }

References PRMFactory(), _prm_, and prm().

Here is the call graph for this function:

◆ PRMFactory() [3/3]

template<GUM_Numeric GUM_SCALAR>

gum::prm::PRMFactory< GUM_SCALAR >::PRMFactory ( const PRMFactory< GUM_SCALAR > & from )

delete

Copy constructor. Don't use it.

References PRMFactory().

Here is the call graph for this function:

◆ ~PRMFactory()

template<GUM_Numeric GUM_SCALAR>

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

override

Destructor.

Definition at line 1315 of file PRMFactory_tpl.h.

                                          {
      GUM_DESTRUCTOR(PRMFactory);
      while (!_namespaces_.empty()) {
        auto ns = _namespaces_.back();
        _namespaces_.pop_back();
        delete ns;
      }
    }

References PRMFactory(), and _namespaces_.

Here is the call graph for this function:

Member Function Documentation

◆ _addInstance_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::_addInstance_	(	PRMClass< GUM_SCALAR > *	type,
		std::string_view	name )

private

Adds an instance to the current model.

Definition at line 1664 of file PRMFactory_tpl.h.

                                                                             {
      PRMInstance< GUM_SCALAR >* i = nullptr;
      try {
        auto s
            = static_cast< PRMSystem< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::SYSTEM));
        i = new PRMInstance< GUM_SCALAR >(name, *type);
        s->add(i);
 
      } catch (OperationNotAllowed const&) {
        if (i) { delete i; }
        throw;
      }
    }

References _checkStack_(), and gum::prm::PRMObject::SYSTEM.

Referenced by addInstance(), and addInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _addParent_() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::_addParent_	(	PRMClass< GUM_SCALAR > *	c,
		PRMAggregate< GUM_SCALAR > *	agg,
		std::string_view	name )

private

Add a parent to an aggregate.

Definition at line 602 of file PRMFactory_tpl.h.

                                                                               {
      auto chains = std::vector< std::string >{std::string(name)};
      auto inputs = std::vector< PRMClassElement< GUM_SCALAR >* >();
      _retrieveInputs_(c, chains, inputs);
 
      switch (agg->agg_type()) {
        case PRMAggregate< GUM_SCALAR >::AggregateType::OR :
        case PRMAggregate< GUM_SCALAR >::AggregateType::AND : {
          if (inputs.front()->type() != *(_retrieveType_("boolean"))) {
            GUM_ERROR(TypeError, "expected booleans")
          }
 
          break;
        }
 
        case PRMAggregate< GUM_SCALAR >::AggregateType::COUNT :
        case PRMAggregate< GUM_SCALAR >::AggregateType::EXISTS :
        case PRMAggregate< GUM_SCALAR >::AggregateType::FORALL : {
          if (!agg->hasLabel()) {
            auto param     = agg->labelValue();
            Idx  label_idx = 0;
 
            while (label_idx < inputs.front()->type()->domainSize()) {
              if (inputs.front()->type()->label(label_idx) == param) { break; }
 
              ++label_idx;
            }
 
            if (label_idx == inputs.front()->type()->domainSize()) {
              GUM_ERROR(NotFound, "could not find label")
            }
 
            agg->setLabel(label_idx);
          }
 
          break;
        }
 
        case PRMAggregate< GUM_SCALAR >::AggregateType::SUM :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MEDIAN :
        case PRMAggregate< GUM_SCALAR >::AggregateType::AMPLITUDE :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MIN :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MAX : {
          break;
        }
 
        default : {
          GUM_ERROR(FatalError, "Unknown aggregator.")
        }
      }
 
      c->addArc(inputs.front()->safeName(), agg->safeName());
    }

Here is the call graph for this function:

◆ _addParent_() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::_addParent_	(	PRMClassElementContainer< GUM_SCALAR > *	c,
		PRMAttribute< GUM_SCALAR > *	agg,
		std::string_view	name )

private

Add a parent to an attribute.

Definition at line 252 of file PRMFactory_tpl.h.

                                                                                           {
      if (c->exists(name)) {
        PRMClassElement< GUM_SCALAR >& elt = c->get(name);
 
        switch (elt.elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_refslot : {
            GUM_ERROR(OperationNotAllowed,
                      "can not add a reference slot as a parent of an attribute")
            break;
          }
 
          case PRMClassElement< GUM_SCALAR >::prm_slotchain : {
            if (static_cast< PRMSlotChain< GUM_SCALAR >& >(elt).isMultiple()) {
              GUM_ERROR(OperationNotAllowed, "can not add a multiple slot chain to an attribute")
            }
 
            c->addArc(name, a->name());
 
            break;
          }
 
          case PRMClassElement< GUM_SCALAR >::prm_attribute :
          case PRMClassElement< GUM_SCALAR >::prm_aggregate : {
            c->addArc(name, a->name());
            break;
          }
 
          default : {
            GUM_ERROR(FatalError, "unknown ClassElement<GUM_SCALAR>")
          }
        }
      } else {
        // Check if name is a slot chain
        PRMSlotChain< GUM_SCALAR >* sc = _buildSlotChain_(c, name);
 
        if (sc == nullptr) {
          GUM_ERROR(NotFound, "found no ClassElement<GUM_SCALAR> with the given name " << name)
        } else if (!sc->isMultiple()) {
          c->add(sc);
          c->addArc(sc->name(), a->name());
        } else {
          delete sc;
          GUM_ERROR(OperationNotAllowed,
                    "Impossible to add a multiple reference slot as"
                    " direct parent of an PRMAttribute<GUM_SCALAR>.");
        }
      }
    }

Referenced by addParent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _addPrefix_()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::PRMFactory< GUM_SCALAR >::_addPrefix_ ( std::string_view str ) const

private

Adds prefix to str iff prefix != "".

Definition at line 1680 of file PRMFactory_tpl.h.

                                                                            {
      if (!_packages_.empty()) {
        std::string full_name = _packages_.back();
        full_name.append(".");
        full_name.append(str);
        return full_name;
      } else {
        return std::string(str);
      }
    }

References _packages_.

Referenced by _retrieveClass_(), _retrieveInterface_(), _retrieveType_(), addRangeType(), continueClass(), continueInterface(), startClass(), startDiscreteType(), startDiscretizedType(), startInterface(), and startSystem().

Here is the caller graph for this function:

◆ _buildAggregateCPF_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::_buildAggregateCPF_ ( PRMSystem< GUM_SCALAR > * model )

private

Builds all Aggregates CPF in the given model. This must be called after all the slot chains have been generated.

◆ _buildSlotChain_()

template<GUM_Numeric GUM_SCALAR>

PRMSlotChain< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_buildSlotChain_	(	PRMClassElementContainer< GUM_SCALAR > *	start,
		std::string_view	name )

private

This methods build a PRMSlotChain<GUM_SCALAR> given a starting element and a string.

Returns: Return a pointer over a PRMSlotChain<GUM_SCALAR> or 0 if no PRMSlotChain<GUM_SCALAR> could be built.

Definition at line 933 of file PRMFactory_tpl.h.

                                                                                               {
      std::vector< std::string > v;
      decomposePath(name, v);
      PRMClassElementContainer< GUM_SCALAR >*    current = start;
      PRMReferenceSlot< GUM_SCALAR >*            ref     = nullptr;
      Sequence< PRMClassElement< GUM_SCALAR >* > elts;
 
      for (size_t i = 0; i < v.size(); ++i) {
        if (!current->exists(v[i])) return nullptr;
        switch (current->get(v[i]).elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_refslot :
            ref = &(static_cast< PRMReferenceSlot< GUM_SCALAR >& >(current->get(v[i])));
            elts.insert(ref);
            current = &(/*const_cast<PRMClassElementContainer<GUM_SCALAR>&>*/ (ref->slotType()));
            break;
 
          case PRMClassElement< GUM_SCALAR >::prm_aggregate :
          case PRMClassElement< GUM_SCALAR >::prm_attribute :
 
            if (i == v.size() - 1) {
              elts.insert(&(current->get(v[i])));
              break;
            } else {
              return nullptr;
            }
 
          default : {
            return nullptr;
          }
        }
      }
 
      GUM_ASSERT(v.size() == elts.size());
 
      current->setOutputNode(*(elts.back()), true);
 
      return new PRMSlotChain< GUM_SCALAR >(name, elts);
    }

References gum::SequenceImplementation< Key, Gen >::back(), gum::prm::decomposePath(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), gum::SequenceImplementation< Key, Gen >::insert(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::prm::PRMClassElement< GUM_SCALAR >::prm_refslot, gum::prm::PRMClassElementContainer< GUM_SCALAR >::setOutputNode(), gum::SequenceImplementation< Key, Gen >::size(), and gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType().

Referenced by _addParent_(), _retrieveInputs_(), and addNoisyOrCompound().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkInterfaceImplementation_()

template<GUM_Numeric GUM_SCALAR>

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

private

Check if c implements correctly all his interfaces.

Definition at line 121 of file PRMFactory_tpl.h.

                                                                                           {
      try {
        // c->implements() throws NotFound if no interface is implemented
        const auto& interfaces = c->implements();
        for (const auto& i: interfaces) {
          for (const auto& node: i->containerDag().nodes()) {
            std::string name = i->get(node).name();
 
            if (!c->exists(name)) {
              GUM_ERROR(PRMTypeError,
                        std::format("class {} does not respect interface {}", c->name(), i->name()))
            }
 
            switch (i->get(node).elt_type()) {
              case PRMClassElement< GUM_SCALAR >::prm_aggregate :
              case PRMClassElement< GUM_SCALAR >::prm_attribute : {
                if ((c->get(name).elt_type() == PRMClassElement< GUM_SCALAR >::prm_attribute)
                    || (c->get(name).elt_type() == PRMClassElement< GUM_SCALAR >::prm_aggregate)) {
                  if (!c->get(name).type().isSubTypeOf(i->get(name).type())) {
                    GUM_ERROR(
                        PRMTypeError,
                        std::format("class {} does not respect interface {}", c->name(), i->name()))
                  }
                } else {
                  GUM_ERROR(
                      PRMTypeError,
                      std::format("class {} does not respect interface {}", c->name(), i->name()))
                }
 
                break;
              }
 
              case PRMClassElement< GUM_SCALAR >::prm_refslot : {
                if (c->get(name).elt_type() == PRMClassElement< GUM_SCALAR >::prm_refslot) {
                  const PRMReferenceSlot< GUM_SCALAR >& ref_i
                      = static_cast< const PRMReferenceSlot< GUM_SCALAR >& >(i->get(name));
                  const PRMReferenceSlot< GUM_SCALAR >& ref_this
                      = static_cast< const PRMReferenceSlot< GUM_SCALAR >& >(c->get(name));
 
                  if (!ref_this.slotType().isSubTypeOf(ref_i.slotType())) {
                    GUM_ERROR(
                        PRMTypeError,
                        std::format("class {} does not respect interface {}", c->name(), i->name()))
                  }
                } else {
                  GUM_ERROR(
                      PRMTypeError,
                      std::format("class {} does not respect interface {}", c->name(), i->name()))
                }
 
                break;
              }
 
              case PRMClassElement< GUM_SCALAR >::prm_slotchain : {
                // Nothing to check: they are automatically inherited
                break;
              }
 
              default : {
                std::string msg = "unexpected ClassElement<GUM_SCALAR> in interface ";
                GUM_ERROR(FatalError, msg + i->name())
              }
            }
          }
        }
      } catch (NotFound const&) {
        // this Class does not implement any Interface
      }
    }

References gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClass< GUM_SCALAR >::implements(), gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::prm::PRMClassElement< GUM_SCALAR >::prm_refslot, gum::prm::PRMClassElement< GUM_SCALAR >::prm_slotchain, and gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType().

Referenced by endClass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkStack_() [1/2]

template<GUM_Numeric GUM_SCALAR>

PRMObject * gum::prm::PRMFactory< GUM_SCALAR >::_checkStack_	(	Idx	i,
		PRMObject::prm_type	obj_type )

private

Return a pointer on a PRMObject at stack.size() - i position after checking the type of the object given obj_type.

Exceptions

FactoryInvalidState Raised if the stack isn't consistent with the

Definition at line 1692 of file PRMFactory_tpl.h.

                                                                                       {
      // Don't forget that Idx are unsigned int
      if (_stack_.size() - i > _stack_.size()) {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
 
      PRMObject* obj = _stack_[_stack_.size() - i];
 
      if (obj->obj_type() != obj_type) {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
 
      return obj;
    }

References _stack_, GUM_ERROR, and gum::prm::PRMObject::obj_type().

Referenced by _addInstance_(), addAggregator(), addArray(), addAttribute(), addAttribute(), addLabel(), addParameter(), addParent(), addTick(), endAggregator(), endAttribute(), endClass(), endDiscreteType(), endDiscretizedType(), endInterface(), endSystem(), incArray(), setCPFByFloatRule(), setCPFByRule(), setCPFByRule(), setRawCPFByColumns(), setRawCPFByColumns(), setRawCPFByFloatColumns(), setRawCPFByFloatLines(), setRawCPFByLines(), setRawCPFByLines(), setReferenceSlot(), and startAggregator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _checkStack_() [2/2]

template<GUM_Numeric GUM_SCALAR>

PRMClassElement< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_checkStack_	(	Idx	i,
		typename PRMClassElement< GUM_SCALAR >::ClassElementType	obj_type )

private

Adds prefix to str iff prefix != "".

Definition at line 1726 of file PRMFactory_tpl.h.

                                                                         {
      // Don't forget that Idx are unsigned int
      if (_stack_.size() - i > _stack_.size()) {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
 
      PRMClassElement< GUM_SCALAR >* obj
          = dynamic_cast< PRMClassElement< GUM_SCALAR >* >(_stack_[_stack_.size() - i]);
 
      if (obj == 0) { GUM_ERROR(FactoryInvalidState, "illegal sequence of calls") }
 
      if (obj->elt_type() != elt_type) {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
 
      return obj;
    }

References _stack_, gum::prm::PRMClassElement< GUM_SCALAR >::elt_type(), and GUM_ERROR.

Here is the call graph for this function:

◆ _checkStackContainter_()

template<GUM_Numeric GUM_SCALAR>

PRMClassElementContainer< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_checkStackContainter_ ( Idx i )

private

Adds prefix to str iff prefix != "".

Definition at line 1709 of file PRMFactory_tpl.h.

                                                              {
      // Don't forget that Idx are unsigned int
      if (_stack_.size() - i > _stack_.size()) {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
 
      PRMObject* obj = _stack_[_stack_.size() - i];
 
      if ((obj->obj_type() == PRMObject::prm_type::CLASS)
          || (obj->obj_type() == PRMObject::prm_type::PRM_INTERFACE)) {
        return static_cast< PRMClassElementContainer< GUM_SCALAR >* >(obj);
      } else {
        GUM_ERROR(FactoryInvalidState, "illegal sequence of calls")
      }
    }

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

Referenced by addParent(), addReferenceSlot(), continueAggregator(), continueAttribute(), and startAttribute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _instantiateSlotChain_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::_instantiateSlotChain_	(	PRMSystem< GUM_SCALAR > *	model,
		PRMInstance< GUM_SCALAR > *	inst,
		PRMReferenceSlot< GUM_SCALAR > *	ref,
		PRMSlotChain< GUM_SCALAR > *	sc )

private

Instantiate a slot chain in the given instance.

◆ _retrieveClass_()

template<GUM_Numeric GUM_SCALAR>

PRMClass< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveClass_ ( std::string_view name ) const

private

Returns a pointer on a class given it's name. Used when building models, meaning that the class name can either be local (need to add the current prefix) or global (no prefix needed).

Exceptions

NotFound If no class matching the name is found.

See also: PRMFactory:: retrieveType

Definition at line 1207 of file PRMFactory_tpl.h.

                                                                                               {
      PRMClass< GUM_SCALAR >* a_class = nullptr;
      std::string             full_name;
 
      // Looking for the type using its name
      if (auto p = _prm_->_classMap_.tryGet(name)) {
        a_class   = *p;
        full_name = name;
      }
 
      // Looking for the type using current package
      std::string prefixed = _addPrefix_(name);
      if (auto p = _prm_->_classMap_.tryGet(prefixed)) {
        if (a_class == nullptr) {
          a_class   = *p;
          full_name = prefixed;
        } else if (full_name != prefixed) {
          GUM_ERROR(DuplicateElement,
                    "Class name '" << name << "' is ambiguous: specify full name.");
        }
      }
 
      // Looking for the class using all declared namespaces
      if (!_namespaces_.empty()) {
        auto ns_list = _namespaces_.back();
        for (gum::Size i = 0; i < ns_list->size(); ++i) {
          std::string ns      = (*ns_list)[i];
          std::string ns_name = ns + "." + std::string(name);
          if (auto p = _prm_->_classMap_.tryGet(ns_name)) {
            if (a_class == 0) {
              a_class   = *p;
              full_name = ns_name;
            } else if (full_name != ns_name) {
              GUM_ERROR(DuplicateElement,
                        "Class name '" << name << "' is ambiguous: specify full name.");
            }
          }
        }
      }
 
      if (a_class == 0) { GUM_ERROR(NotFound, "Class '" << name << "' not found, check imports.") }
 
      return a_class;
    }

References _addPrefix_(), _namespaces_, _prm_, and GUM_ERROR.

Referenced by addArray(), addInstance(), addInstance(), addReferenceSlot(), isClassOrInterface(), retrieveClass(), and startClass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _retrieveCommonType_()

template<GUM_Numeric GUM_SCALAR>

PRMType * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveCommonType_ ( const std::vector< PRMClassElement< GUM_SCALAR > * > & elts )

private

Retrieve the common PRMType of a vector of PRMClassElement<GUM_SCALAR>.

The vector elts must only contains PRMClassElement<GUM_SCALAR> with a PRMType, i.e. PRMAttribute<GUM_SCALAR>, PRMAggregate and PRMSlotChain<GUM_SCALAR>. If not a WrongClassElement is raised.

A common PRMType is PRMType t such as t.isSuperTypeOf(elts[i]) for 0 < i < elts.size(), where elts is a PRMType container.

Parameters

elts	A vector of PRMClassElement<GUM_SCALAR>.

Returns: Returns the common super PRMType of all PRMClassElement<GUM_SCALAR> un elts.

Exceptions

WrongClassElement	Raised if elts contains a PRMClassElement<GUM_SCALAR> without a PRMType.
NotFound	Raised if there exists no common super type of all PRMClassElement<GUM_SCALAR> in elts.

Definition at line 1029 of file PRMFactory_tpl.h.

                                                                 {
      const PRMType*                 current = nullptr;
      HashTable< std::string, Size > counters;
      // Finding all types and super types
 
      for (const auto& elt: elts) {
        try {
          current = &((*elt).type());
 
          while (current != 0) {
            // Filling counters
            if (auto p = counters.tryGet(current->name())) {
              ++(*p);
            } else {
              counters.insert(current->name(), 1);
            }
 
            // Loop guard
            if (current->isSubType()) {
              current = &(current->superType());
            } else {
              current = nullptr;
            }
          }
        } catch (OperationNotAllowed const&) {
          GUM_ERROR(WrongClassElement, "found a ClassElement<GUM_SCALAR> without a type")
        }
      }
 
      // We need to find the most specialized (i.e. max depth) common type
      PRMType* result = nullptr;
 
      int max_depth = -1;
 
      int current_depth = 0;
 
      for (const auto& elt: counters) {
        if ((elt.second) == elts.size()) {
          current_depth = _typeDepth_(_retrieveType_(elt.first));
 
          if (current_depth > max_depth) {
            max_depth = current_depth;
            result    = _retrieveType_(elt.first);
          }
        }
      }
 
      if (result) { return result; }
 
      GUM_ERROR(NotFound, "could not find a common type")
    }

References _retrieveType_(), _typeDepth_(), GUM_ERROR, gum::HashTable< Key, Val >::insert(), gum::Variable::name(), and gum::HashTable< Key, Val >::tryGet().

Referenced by _retrieveInputs_(), addNoisyOrCompound(), and retrieveCommonType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _retrieveInputs_()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInputs_	(	PRMClass< GUM_SCALAR > *	c,
		const std::vector< std::string > &	chains,
		std::vector< PRMClassElement< GUM_SCALAR > * > &	inputs )

private

Retrieve inputs for an PRMAggregate.

The vector chains contains names of the PRMAggregate inputs. If a name does not match an existing PRMClassElement<GUM_SCALAR> in c, then a call to PRMFactory:: buildSlotChains() is made. Such created PRMSlotChain<GUM_SCALAR> are added to c.

Parameters

c	The class in which the PRMAggregate is defined.
chains	Vector of the PRMAggregate inputs names.
inputs	Vector filled with the PRMClassElement<GUM_SCALAR> matching the names in chains.

Returns: true if there was at least one slotchain in chains.

Exceptions

NotFound Raised if a name in chains does not match a legal PRMSlotChain<GUM_SCALAR> or an existing PRMClassElement<GUM_SCALAR> in c.

Definition at line 974 of file PRMFactory_tpl.h.

                                                             {
      bool retVal = false;
 
      for (size_t i = 0; i < chains.size(); ++i) {
        if (c->exists(chains[i])) {
          inputs.push_back(&(c->get(chains[i])));
          retVal = retVal || PRMClassElement< GUM_SCALAR >::isSlotChain(*(inputs.back()));
        } else {
          inputs.push_back(_buildSlotChain_(c, chains[i]));
          retVal = true;
 
          if (inputs.back()) {
            c->add(inputs.back());
          } else {
            GUM_ERROR(NotFound, "unknown slot chain")
          }
        }
      }
 
      PRMType* t = _retrieveCommonType_(inputs);
 
      std::vector< std::pair< PRMClassElement< GUM_SCALAR >*, PRMClassElement< GUM_SCALAR >* > >
          toAdd;
 
      for (const auto& elt: inputs) {
        if ((*elt).type() != (*t)) {
          if (PRMClassElement< GUM_SCALAR >::isSlotChain(*elt)) {
            PRMSlotChain< GUM_SCALAR >* sc = static_cast< PRMSlotChain< GUM_SCALAR >* >(elt);
            std::stringstream           name;
 
            for (Size idx = 0; idx < sc->chain().size() - 1; ++idx) {
              name << sc->chain().atPos(idx)->name() << ".";
            }
 
            name << ".(" << t->name() << ")" << sc->lastElt().name();
 
            if (c->exists(name.str())) {
              toAdd.push_back(std::make_pair(elt, &(c->get(name.str()))));
            } else {
              toAdd.push_back(std::make_pair(elt, _buildSlotChain_(c, name.str())));
            }
          } else {
            toAdd.push_back(
                std::make_pair(elt, &(c->get(std::format("({}){}", t->name(), elt->name())))));
          }
        }
      }
 
      return retVal;
    }

References _buildSlotChain_(), _retrieveCommonType_(), gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMSlotChain< GUM_SCALAR >::chain(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isSlotChain(), gum::prm::PRMSlotChain< GUM_SCALAR >::lastElt(), and gum::Variable::name().

Referenced by _addParent_(), and addAggregator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _retrieveInstanceSequence_()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInstanceSequence_	(	PRMInstance< GUM_SCALAR > *	inst,
		Sequence< PRMInstance< GUM_SCALAR > * > &	seq,
		PRMSlotChain< GUM_SCALAR > *	sc )

private

Fill seq with the sequence of instance build using inst as the instantiation of sc-> class and seeking each instantiation of reference in sc.

Returns: Returns the name of the corresponding PRMSlotChain<GUM_SCALAR>.

◆ _retrieveInterface_()

template<GUM_Numeric GUM_SCALAR>

PRMInterface< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInterface_ ( std::string_view name ) const

private

Returns a pointer on an interface given it's name. Used when building models, meaning that the interface name can either be local (need to add the current prefix) or global (no prefix needed).

Exceptions

NotFound If no class matching the name is found.

See also: PRMFactory:: retrieveType

Definition at line 1254 of file PRMFactory_tpl.h.

                                                                               {
      PRMInterface< GUM_SCALAR >* a_interface = nullptr;
      std::string                 full_name;
 
      // Looking for the type using its name
      if (auto p = _prm_->_interfaceMap_.tryGet(name)) {
        a_interface = *p;
        full_name   = name;
      }
 
      // Looking for the type using current package
      std::string prefixed = _addPrefix_(name);
      if (auto p = _prm_->_interfaceMap_.tryGet(prefixed)) {
        if (a_interface == nullptr) {
          a_interface = *p;
          full_name   = prefixed;
        } else if (full_name != prefixed) {
          GUM_ERROR(DuplicateElement,
                    "Interface name '" << name << "' is ambiguous: specify full name.");
        }
      }
 
      // Looking for the interf using all declared namespaces
      if (!_namespaces_.empty()) {
        auto ns_list = _namespaces_.back();
        // for( const auto & ns : *( _namespaces_.top()) ) {
        for (gum::Size i = 0; i < ns_list->size(); ++i) {
          std::string ns      = (*ns_list)[i];
          std::string ns_name = ns + "." + std::string(name);
 
          if (auto p = _prm_->_interfaceMap_.tryGet(ns_name)) {
            if (a_interface == nullptr) {
              a_interface = *p;
              full_name   = ns_name;
            } else if (full_name != ns_name) {
              GUM_ERROR(DuplicateElement,
                        "Interface name '" << name << "' is ambiguous: specify full name.");
            }
          }
        }
      }
 
      if (a_interface == nullptr) {
        GUM_ERROR(NotFound, "Interface '" << name << "' not found, check imports.")
      }
 
      return a_interface;
    }

References _addPrefix_(), _namespaces_, _prm_, and GUM_ERROR.

Referenced by addReferenceSlot(), continueInterface(), isClassOrInterface(), startClass(), and startInterface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _retrieveType_()

template<GUM_Numeric GUM_SCALAR>

PRMType * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveType_ ( std::string_view name ) const

private

Returns a pointer on a PRMType given it's name. Since the type can be given either with it's local name (without the prefix), full name (with the prefix) or can come from an import unit, or maybe one day with a using declaration we need some processing to find it.

The following precedences on finding the name is used:

name
prefix.name
import_1.name
import_2.name
...
import_N.name In the case a local name is used multiple time, it's preferable to use it's full name.
Exceptions

OperationNotAllowed If the type is undeclared.

Definition at line 1146 of file PRMFactory_tpl.h.

                                                                               {
      PRMType*    type = nullptr;
      std::string full_name;
 
      // Looking for the type using its name
      if (auto p = _prm_->_typeMap_.tryGet(name)) {
        type      = *p;
        full_name = name;
      }
 
      // Looking for the type in current package
      std::string prefixed = _addPrefix_(name);
      if (auto p = _prm_->_typeMap_.tryGet(prefixed)) {
        if (type == 0) {
          type      = *p;
          full_name = prefixed;
        } else if (full_name != prefixed) {
          GUM_ERROR(DuplicateElement, "Type name '" << name << "' is ambiguous: specify full name.")
        }
      }
 
      // Looking for the type relatively to current package
      std::string relatif_ns = currentPackage();
      if (auto last_dot = relatif_ns.find_last_of('.'); last_dot != std::string::npos) {
        relatif_ns = relatif_ns.substr(0, last_dot) + '.' + std::string(name);
        if (auto p = _prm_->_typeMap_.tryGet(relatif_ns)) {
          if (type == 0) {
            type      = *p;
            full_name = relatif_ns;
          } else if (full_name != relatif_ns) {
            GUM_ERROR(DuplicateElement,
                      "Type name '" << name << "' is ambiguous: specify full name.");
          }
        }
      }
 
 
      // Looking for the type using all declared namespaces
      if (!_namespaces_.empty()) {
        auto ns_list = _namespaces_.back();
        for (gum::Size i = 0; i < ns_list->size(); ++i) {
          std::string ns      = (*ns_list)[i];
          std::string ns_name = ns + "." + std::string(name);
          if (auto p = _prm_->_typeMap_.tryGet(ns_name)) {
            if (type == 0) {
              type      = *p;
              full_name = ns_name;
            } else if (full_name != ns_name) {
              GUM_ERROR(DuplicateElement,
                        "Type name '" << name << "' is ambiguous: specify full name.");
            }
          }
        }
      }
 
      if (type == 0) { GUM_ERROR(NotFound, "Type '" << name << "' not found, check imports.") }
 
      return type;
    }

References _addPrefix_(), _namespaces_, _prm_, currentPackage(), and GUM_ERROR.

Referenced by _addParent_(), _retrieveCommonType_(), addAggregator(), retrieveType(), startAggregator(), startAttribute(), and startDiscreteType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _typeDepth_()

template<GUM_Numeric GUM_SCALAR>

int gum::prm::PRMFactory< GUM_SCALAR >::_typeDepth_ ( const PRMType * t )

private

Returns the inheritance depth of a PRMType.

This used by PRMFactory:: retrieveCommonType. This returns 0 if t does not have a super type.

Parameters

t	The PRMType for which we compute its depth.

Returns: Returns the depth of t.

Definition at line 1747 of file PRMFactory_tpl.h.

                                                              {
      int            depth   = 0;
      const PRMType* current = t;
 
      while (current->isSubType()) {
        ++depth;
        current = &(current->superType());
      }
 
      return depth;
    }

Referenced by _retrieveCommonType_().

Here is the caller graph for this function:

◆ addAggregator()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addAggregator	(	std::string_view	name,
		std::string_view	agg_type,
		const std::vector< std::string > &	chains,
		const std::vector< std::string > &	params,
		std::string_view	type = "" )

overridevirtual

Add an aggregator in the current declared class.

If at least one parent of an aggregator is a PRMSlotChain<GUM_SCALAR>, then all of it's parents must be PRMSlotChain<GUM_SCALAR>. When an aggregator parents are only composed of PRMAttribute<GUM_SCALAR> and PRMAggregate, then it is directly added as an PRMAttribute<GUM_SCALAR> to it's Class<GUM_SCALAR>.

Parameters

name	The name of this aggregator.
agg_type	The name of the aggregator type of this aggregator.
chains	The set of chains on which this aggregate applies.
params	The list of parameters for this aggregator.
type	Some aggregators have a user defined type, use this parameter to define it.

Exceptions

OperationNotAllowed	Raised if one or more parameters misses or are not correct.
TypeError	Raised if the aggregator's type or one or more of the chains are not of the good type.

Implements gum::prm::IPRMFactory.

Definition at line 665 of file PRMFactory_tpl.h.

                                                                                       {
      PRMClass< GUM_SCALAR >* c
          = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
      // Checking call legality
      std::string name_s(name), agg_type_s(agg_type), type_s(type);
 
      if (chains.size() == 0) {
        GUM_ERROR(OperationNotAllowed, "a PRMAggregate<GUM_SCALAR> requires at least one parent")
      }
 
      // Retrieving the parents of the aggregate
      std::vector< PRMClassElement< GUM_SCALAR >* > inputs;
 
      // This helps knowing if the aggregate has parents outside the current
      // class
      // (see below)
      bool hasSC = _retrieveInputs_(c, chains, inputs);
 
      // Checking that all inputs shares the same PRMType (trivial
      // if
      // inputs.size() == 1)
      if (inputs.size() > 1) {
        for (auto iter = inputs.begin() + 1; iter != inputs.end(); ++iter) {
          if ((**(iter - 1)).type() != (**iter).type()) {
            GUM_ERROR(TypeError, "found different types")
          }
        }
      }
 
      // Different treatments for different types of aggregate.
      PRMAggregate< GUM_SCALAR >* agg = nullptr;
 
      switch (PRMAggregate< GUM_SCALAR >::str2enum(agg_type_s)) {
        case PRMAggregate< GUM_SCALAR >::AggregateType::OR :
        case PRMAggregate< GUM_SCALAR >::AggregateType::AND : {
          if (inputs.front()->type() != *(_retrieveType_("boolean"))) {
            GUM_ERROR(TypeError, "expected booleans")
          }
          if (params.size() != 0) { GUM_ERROR(OperationNotAllowed, "invalid number of paramaters") }
 
          agg = new PRMAggregate< GUM_SCALAR >(name_s,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type_s),
                                               inputs.front()->type());
 
          break;
        }
 
        case PRMAggregate< GUM_SCALAR >::AggregateType::EXISTS :
        case PRMAggregate< GUM_SCALAR >::AggregateType::FORALL : {
          if (params.size() != 1) { GUM_ERROR(OperationNotAllowed, "invalid number of parameters") }
 
          Idx label_idx = 0;
 
          while (label_idx < inputs.front()->type()->domainSize()) {
            if (inputs.front()->type()->label(label_idx) == params.front()) { break; }
 
            ++label_idx;
          }
 
          if (label_idx == inputs.front()->type()->domainSize()) {
            GUM_ERROR(NotFound, "could not find label")
          }
 
          // Creating and adding the PRMAggregate<GUM_SCALAR>
          agg = new PRMAggregate< GUM_SCALAR >(name_s,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type_s),
                                               *(_retrieveType_("boolean")),
                                               label_idx);
          agg->label();
 
          break;
        }
 
        case PRMAggregate< GUM_SCALAR >::AggregateType::SUM :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MEDIAN :
        case PRMAggregate< GUM_SCALAR >::AggregateType::AMPLITUDE :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MIN :
        case PRMAggregate< GUM_SCALAR >::AggregateType::MAX : {
          if (params.size() != 0) { GUM_ERROR(OperationNotAllowed, "invalid number of parameters") }
 
          auto output_type = _retrieveType_(type_s);
 
          // Creating and adding the PRMAggregate<GUM_SCALAR>
          agg = new PRMAggregate< GUM_SCALAR >(name_s,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type_s),
                                               *output_type);
 
          break;
        }
 
        case PRMAggregate< GUM_SCALAR >::AggregateType::COUNT : {
          if (params.size() != 1) { GUM_ERROR(OperationNotAllowed, "invalid number of parameters") }
 
          Idx label_idx = 0;
 
          while (label_idx < inputs.front()->type()->domainSize()) {
            if (inputs.front()->type()->label(label_idx) == params.front()) { break; }
 
            ++label_idx;
          }
 
          if (label_idx == inputs.front()->type()->domainSize()) {
            GUM_ERROR(NotFound, "could not find label")
          }
 
          auto output_type = _retrieveType_(type_s);
 
          // Creating and adding the PRMAggregate<GUM_SCALAR>
          agg = new PRMAggregate< GUM_SCALAR >(name_s,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type_s),
                                               *output_type,
                                               label_idx);
 
          break;
        }
 
        default : {
          GUM_ERROR(FatalError, "Unknown aggregator.")
        }
      }
 
      std::string safe_name = agg->safeName();
 
      try {
        if (hasSC) {
          try {
            c->add(agg);
          } catch (DuplicateElement const&) { c->overload(agg); }
        } else {
          // Inner aggregators can be directly used as attributes
          auto attr
              = new PRMScalarAttribute< GUM_SCALAR >(agg->name(), agg->type(), agg->buildImpl());
 
          try {
            try {
              c->add(attr);
            } catch (DuplicateElement const&) { c->overload(attr); }
          } catch (...) {
            delete attr;
            throw;
          }
 
          delete agg;
        }
      } catch (DuplicateElement const&) {
        delete agg;
        throw;
      }
 
      for (const auto& elt: inputs) {
        c->addArc(elt->safeName(), safe_name);
      }
    }

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addArray()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addArray	(	std::string_view	type,
		std::string_view	name,
		Size	size )

overridevirtual

Creates an array with the given number of instances of the given type.

PRMInstance<GUM_SCALAR> are name using "name" as prefix and adding the suffix "[i]", with "i" being the position of the instance in the array.

Implements gum::prm::IPRMFactory.

Definition at line 849 of file PRMFactory_tpl.h.

                                                                   {
      PRMSystem< GUM_SCALAR >* model
          = static_cast< PRMSystem< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::SYSTEM));
      PRMClass< GUM_SCALAR >*    c    = _retrieveClass_(type);
      PRMInstance< GUM_SCALAR >* inst = 0;
 
      try {
        std::string name_str(name);
        model->addArray(name_str, *c);
 
        for (Size i = 0; i < size; ++i) {
          inst = new PRMInstance< GUM_SCALAR >(std::format("{}[{}]", name, i), *c);
          model->add(name_str, inst);
          inst = nullptr;
        }
      } catch (PRMTypeError const&) {
        delete inst;
        throw;
      } catch (NotFound const&) {
        delete inst;
        throw;
      }
    }

References _checkStack_(), _retrieveClass_(), gum::prm::PRMSystem< GUM_SCALAR >::add(), gum::prm::PRMSystem< GUM_SCALAR >::addArray(), and gum::prm::PRMObject::SYSTEM.

Referenced by gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::_addInstances_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addAttribute() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addAttribute ( PRMAttribute< GUM_SCALAR > * attr )

virtual

Add an already created attribute to the current class.

Use this method when you must add functions, such as Noisy-Or.

Use this method when you need to add functions, such as Noisy-Or. The attribute CPT is checked for parents and arcs will be added using the DiscreteVariable pointers, thus be careful to use those of the attributes, aggregates and slotchains of the current class. gum::prm::Class<GUM_SCALAR>::insertArc() will be called for each found parent of attr, so you should overload gum::prm::PRMAttribute<GUM_SCALAR>::addParent() to prevent duplication errors. Such class exists: gum::prm::PRMFuncAttribute .

The pointer is given to the class, so do not worry about deleting it.

Parameters

attr	The attribute added to the current class.

Exceptions

NotFound Raised if one of the DiscreteVariable in attr CPT does not match any PRMClassElement<GUM_SCALAR> in this.

Definition at line 227 of file PRMFactory_tpl.h.

                                                                                {
      PRMClass< GUM_SCALAR >* c
          = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
      c->add(attr);
      Size                                       count = 0;
      const Sequence< const DiscreteVariable* >& vars  = attr->cpf().variablesSequence();
 
      for (const auto& node: c->containerDag().nodes()) {
        try {
          if (vars.exists(&(c->get(node).type().variable()))) {
            ++count;
 
            if (&(attr->type().variable()) != &(c->get(node).type().variable())) {
              c->addArc(c->get(node).safeName(), attr->safeName());
            }
          }
        } catch (OperationNotAllowed const&) {}
      }
 
      if (count != attr->cpf().variablesSequence().size()) {
        GUM_ERROR(NotFound, "unable to found all parents of this attribute")
      }
    }

References _checkStack_(), gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMObject::CLASS, gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), gum::SequenceImplementation< Key, Gen >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), GUM_ERROR, gum::NodeGraphPart::nodes(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAttribute< GUM_SCALAR >::type(), and gum::prm::PRMType::variable().

Here is the call graph for this function:

◆ addAttribute() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addAttribute	(	std::string_view	type,
		std::string_view	name )

overridevirtual

Add an attribute to an interface.

Implements gum::prm::IPRMFactory.

Definition at line 1512 of file PRMFactory_tpl.h.

                                                                                        {
      _checkStack_(1, PRMObject::prm_type::PRM_INTERFACE);
      startAttribute(type, name);
      endAttribute();
    }

References _checkStack_(), endAttribute(), gum::prm::PRMObject::PRM_INTERFACE, and startAttribute().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateInterfaces_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateInterfaces_(), addNoisyOrCompound(), and gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addImport()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addImport ( std::string_view name )

overridevirtual

Add an import for namespace lookup.

When loading a module, you should push all import declarations using this method. The order in which you add imports will impact name resolution (first found, first used).

Imports are sync with packages: when you push a new package a new empty list of imports is added. When you pop a package the current list of imports is discarded and the previous one is restored.

Parameters

name	The name of the package for all further objects.

Implements gum::prm::IPRMFactory.

Definition at line 1784 of file PRMFactory_tpl.h.

                                                                {
      if (name.size() == 0) { GUM_ERROR(OperationNotAllowed, "illegal import name") }
      if (_namespaces_.empty()) { _namespaces_.push_back(new List< std::string >()); }
      _namespaces_.back()->push_back(std::string(name));
    }

References _namespaces_, and GUM_ERROR.

◆ addInstance() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addInstance	(	std::string_view	type,
		std::string_view	name )

overridevirtual

Add an instance to the model.

Implements gum::prm::IPRMFactory.

Definition at line 1589 of file PRMFactory_tpl.h.

                                                                                       {
      auto c = _retrieveClass_(type);
 
      // If class contains parameters, calls the proper addIsntance method
      if (c->parameters().size() > 0) {
        HashTable< std::string, double > params;
        addInstance(type, name, params);
 
      } else {
        _addInstance_(c, name);
      }
    }

References _addInstance_(), _retrieveClass_(), and addInstance().

Referenced by gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::_addInstances_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_(), and addInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addInstance() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addInstance	(	std::string_view	type,
		std::string_view	name,
		const HashTable< std::string, double > &	params )

overridevirtual

Add an instance with params as values of type's parameters.

Implements gum::prm::IPRMFactory.

Definition at line 1603 of file PRMFactory_tpl.h.

                                                                                             {
      auto c = _retrieveClass_(type);
 
      if (c->parameters().empty()) {
        if (params.empty()) {
          _addInstance_(c, name);
        } else {
          GUM_ERROR(OperationNotAllowed, "Class " << type << " does not have parameters")
        }
 
      } else {
        auto my_params = params;
        // Adding all parameters to my_params
        for (const auto& p: c->parameters()) {
          if (!my_params.exists(p->name())) { my_params.insert(p->name(), p->value()); }
        }
 
        // Building sub class name using my_params
        std::stringstream sBuff;
        sBuff << c->name() << "<";
 
        for (const auto& p: my_params) {
          sBuff << p.first << "=" << p.second << ",";
        }
 
        // Removing last , and adding closing >
        std::string sub_c = sBuff.str().substr(0, sBuff.str().size() - 1) + ">";
 
        // Adding class in current package
        try {
          auto pck_cpy = _packages_;
          _packages_.clear();
 
          startClass(sub_c, c->name());
 
          // Update inherited parameters
          for (auto p: my_params) {
            auto type = static_cast< PRMParameter< GUM_SCALAR >& >(c->get(p.first)).valueType();
            if (type == PRMParameter< GUM_SCALAR >::ParameterType::INT) {
              addParameter("int", p.first, p.second);
 
            } else {
              addParameter("real", p.first, p.second);
            }
          }
 
          endClass();
 
          _packages_ = pck_cpy;
 
        } catch (DuplicateElement const&) {
          // Sub Class already exists in this system
        }
        c = _retrieveClass_(sub_c);
        _addInstance_(c, name);
      }
    }

References _addInstance_(), _packages_, _retrieveClass_(), addParameter(), gum::HashTable< Key, Val >::empty(), endClass(), GUM_ERROR, gum::prm::PRMParameter< GUM_SCALAR >::INT, startClass(), and gum::prm::PRMParameter< GUM_SCALAR >::valueType().

Here is the call graph for this function:

◆ addLabel()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addLabel	(	std::string_view	l,
		std::string_view	ext = "" )

overridevirtual

Add a label to the current discrete type.

Parameters

l	The label value.
ext	The super type label for which l is an extension.

Exceptions

OperationNotAllowed	Raised if the current type does not have a super type, see PRMFactory::addLabel(const std::string&).
DuplicateElement	Raised if a label with the same value already exists.
NotFound	Raised if ext does not match any label in the current type's super type.

Implements gum::prm::IPRMFactory.

Definition at line 1385 of file PRMFactory_tpl.h.

                                                                                    {
      if (extends.empty()) {
        PRMType*           t = static_cast< PRMType* >(_checkStack_(1, PRMObject::prm_type::TYPE));
        LabelizedVariable* var = dynamic_cast< LabelizedVariable* >(t->_var_);
 
        if (!var) {
          GUM_ERROR(FatalError, "the current type's variable is not a LabelizedVariable.")
        } else if (t->_superType_) {
          GUM_ERROR(OperationNotAllowed, "current type is a subtype.")
        }
 
        try {
          var->addLabel(l);
        } catch (DuplicateElement const&) {
          GUM_ERROR(DuplicateElement, "a label '" << l << "' already exists")
        }
      } else {
        PRMType*           t = static_cast< PRMType* >(_checkStack_(1, PRMObject::prm_type::TYPE));
        LabelizedVariable* var = dynamic_cast< LabelizedVariable* >(t->_var_);
 
        if (!var) {
          GUM_ERROR(FatalError, "the current type's variable is not a LabelizedVariable.")
        } else if (!t->_superType_) {
          GUM_ERROR(OperationNotAllowed, "current type is not a subtype.")
        }
 
        bool found = false;
 
        for (Idx i = 0; i < t->_superType_->_var_->domainSize(); ++i) {
          if (t->_superType_->_var_->label(i) == extends) {
            try {
              var->addLabel(l);
            } catch (DuplicateElement const&) {
              GUM_ERROR(DuplicateElement, "a label '" << l << "' already exists")
            }
 
            t->_label_map_->push_back(i);
 
            found = true;
            break;
          }
        }
 
        if (!found) { GUM_ERROR(NotFound, "inexistent label in super type.") }
      }
    }

References _checkStack_(), gum::LabelizedVariable::addLabel(), gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::DiscreteVariable::label(), and gum::prm::PRMObject::TYPE.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildTypes_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateType_(), and gum::prm::LayerGenerator< GUM_SCALAR >::_generateType_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addNoisyOrCompound()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound	(	std::string_view	name,
		const std::vector< std::string > &	chains,
		const std::vector< float > &	numbers,
		float	leak,
		const std::vector< std::string > &	label )

overridevirtual

Add a compound noisy-or as an PRMAttribute<GUM_SCALAR> to the current Class<GUM_SCALAR>.

The type of a noisy-or must be a boolean.

Parameters

name	the name of the PRMAttribute<GUM_SCALAR> added as a noisy-or.
chains	the list of parents of the noisy-or.
numbers	the list of weights for each parent. Can consist of only one value which will be applied to all the parents.
leak	the leak
label	the label on which the noisy-or applies, can be an empty string (the noisy-or will behave as if chains are all booleans).

Exceptions

NotFound	Raised if one of the chains or the label is not found.
FactoryInvalidState	Raised if a Class<GUM_SCALAR> is not the current declared PRMObject.
OperationNotAllowed	Raised if for some reasons the parameters are invalid.

Implements gum::prm::IPRMFactory.

Definition at line 1083 of file PRMFactory_tpl.h.

                                                                                            {
      if (currentType() != PRMObject::prm_type::CLASS) {
        GUM_ERROR(gum::FactoryInvalidState, "invalid state to add a noisy-or")
      }
 
      PRMClass< GUM_SCALAR >* c = dynamic_cast< gum::prm::PRMClass< GUM_SCALAR >* >(getCurrent());
 
      std::vector< PRMClassElement< GUM_SCALAR >* > parents;
 
      for (const auto& elt: chains)
        parents.push_back(&(c->get(elt)));
 
      PRMType* common_type = _retrieveCommonType_(parents);
 
      for (size_t idx = 0; idx < parents.size(); ++idx) {
        if (parents[idx]->type() != (*common_type)) {
          PRMClassElement< GUM_SCALAR >* parent = parents[idx];
          // Either safe_name is an non existing slot chain or an existing cast
          // descendant
          std::string safe_name = parent->cast(*common_type);
 
          if (!c->exists(safe_name)) {
            if (PRMClassElement< GUM_SCALAR >::isSlotChain(*parent)) {
              parents[idx] = _buildSlotChain_(c, safe_name);
              c->add(parents[idx]);
            } else {
              GUM_ERROR(NotFound, "unable to find parent")
            }
          } else {
            parents[idx] = &(c->get(safe_name));
          }
        }
      }
 
      if (numbers.size() == 1) {
        auto impl = new gum::MultiDimNoisyORCompound< GUM_SCALAR >(leak, numbers.front());
        auto attr = new PRMScalarAttribute< GUM_SCALAR >(name, retrieveType("boolean"), impl);
        addAttribute(attr);
      } else if (numbers.size() == parents.size()) {
        gum::MultiDimNoisyORCompound< GUM_SCALAR >* noisy
            = new gum::MultiDimNoisyORCompound< GUM_SCALAR >(leak);
        gum::prm::PRMFuncAttribute< GUM_SCALAR >* attr
            = new gum::prm::PRMFuncAttribute< GUM_SCALAR >(name, retrieveType("boolean"), noisy);
 
        for (size_t idx = 0; idx < numbers.size(); ++idx) {
          noisy->causalWeight(parents[idx]->type().variable(), numbers[idx]);
        }
 
        addAttribute(attr);
      } else {
        GUM_ERROR(OperationNotAllowed, "invalid parameters for a noisy or")
      }
 
      if (!labels.empty()) {
        GUM_ERROR(OperationNotAllowed, "labels definitions not handle for noisy-or")
      }
    }

References _buildSlotChain_(), _retrieveCommonType_(), gum::prm::PRMClass< GUM_SCALAR >::add(), addAttribute(), gum::prm::PRMClassElement< GUM_SCALAR >::cast(), gum::MultiDimICIModel< GUM_ELEMENT >::causalWeight(), gum::prm::PRMObject::CLASS, currentType(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), getCurrent(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isSlotChain(), and retrieveType().

Here is the call graph for this function:

◆ addParameter()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addParameter	(	std::string_view	type,
		std::string_view	name,
		double	value )

overridevirtual

Add a parameter to the current class with a default value.

A parameter with a default value is an PRMAttribute<GUM_SCALAR> (aka mutable PRMAttribute<GUM_SCALAR>) with no parents and with a CPF filled with 1.

Parameters

type	The type of this parameter.
name	The name of this parameter.
value	The label used as default value for this parameter.

Implements gum::prm::IPRMFactory.

Definition at line 534 of file PRMFactory_tpl.h.

                                                                        {
      auto c = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
 
      PRMParameter< GUM_SCALAR >* p = nullptr;
      if (type == "int") {
        p = new PRMParameter< GUM_SCALAR >(name,
                                           PRMParameter< GUM_SCALAR >::ParameterType::INT,
                                           (GUM_SCALAR)value);
      } else if (type == "real") {
        p = new PRMParameter< GUM_SCALAR >(name,
                                           PRMParameter< GUM_SCALAR >::ParameterType::REAL,
                                           (GUM_SCALAR)value);
      }
 
      try {
        c->add(p);
      } catch (DuplicateElement const&) { c->overload(p); }
    }

References _checkStack_(), gum::prm::PRMObject::CLASS, gum::prm::PRMParameter< GUM_SCALAR >::INT, and gum::prm::PRMParameter< GUM_SCALAR >::REAL.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_addParameters_(), and addInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addParent()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addParent ( std::string_view name )

overridevirtual

Tells the factory that we add a parent to the current declared attribute.

The name can refer to an already declared attribute or aggregate of the same class. It can also be a slot chain only if there is no multiple reference in it.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 304 of file PRMFactory_tpl.h.

                                                                {
      PRMClassElementContainer< GUM_SCALAR >* c = _checkStackContainter_(2);
      try {
        // Retrieving pointers
        PRMAttribute< GUM_SCALAR >* a = static_cast< PRMAttribute< GUM_SCALAR >* >(
            _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
        _addParent_(c, a, name);
      } catch (FactoryInvalidState const&) {
        auto agg = static_cast< PRMAggregate< GUM_SCALAR >* >(
            _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_aggregate));
        _addParent_(static_cast< PRMClass< GUM_SCALAR >* >(c), agg, name);
      }
    }

References _addParent_(), _checkStack_(), _checkStackContainter_(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAggregates_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAttribute_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addRangeType()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addRangeType	(	std::string_view	name,
		long	minVal,
		long	maxVal )

overridevirtual

Add a range variable type declaration.

Parameters

name	The variable's name
minVal	The variable's lower bound.
maxVal	The variable's upper bound.

Exceptions

DuplicateElement	Raised if an object with the same name already exists.
OperationNotAllowed	Raised if the range variable is not a valid discrete type.

Implements gum::prm::IPRMFactory.

Definition at line 1488 of file PRMFactory_tpl.h.

                                                                                             {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_typeMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, std::format("\"{}' is already used.", real_name))
      }
 
      auto var = RangeVariable(real_name, "", minVal, maxVal);
      auto t   = new PRMType(var);
 
      if (t->variable().domainSize() < 2) {
        GUM_ERROR(OperationNotAllowed, "current type is not a valid discrete type")
      }
 
      _prm_->_typeMap_.insert(t->name(), t);
      _prm_->_types_.insert(t);
    }

References _addPrefix_(), _prm_, and GUM_ERROR.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildIntTypes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addReferenceSlot()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addReferenceSlot	(	std::string_view	type,
		std::string_view	name,
		bool	isArray )

overridevirtual

Tells the factory that we started declaring a slot.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 824 of file PRMFactory_tpl.h.

                                                                              {
      PRMClassElementContainer< GUM_SCALAR >* owner    = _checkStackContainter_(1);
      PRMClassElementContainer< GUM_SCALAR >* slotType = 0;
 
      try {
        slotType = _retrieveClass_(type);
      } catch (NotFound const&) {
        try {
          slotType = _retrieveInterface_(type);
        } catch (NotFound const&) {
          GUM_ERROR(NotFound, "unknown ReferenceSlot<GUM_SCALAR> slot type")
        }
      }
 
      PRMReferenceSlot< GUM_SCALAR >* ref
          = new PRMReferenceSlot< GUM_SCALAR >(name, *slotType, isArray);
 
      try {
        owner->add(ref);
      } catch (DuplicateElement const&) { owner->overload(ref); }
    }

References _checkStackContainter_(), _retrieveClass_(), _retrieveInterface_(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::add(), GUM_ERROR, and gum::prm::PRMClassElementContainer< GUM_SCALAR >::overload().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_addReferenceSlots_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateInterfaces_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateInterfaces_(), and gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addTick()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::addTick ( double tick )

overridevirtual

Add a tick to the current discretized type.

Parameters

tick	The tick value.

Implements gum::prm::IPRMFactory.

Definition at line 1460 of file PRMFactory_tpl.h.

                                                      {
      PRMType* t = static_cast< PRMType* >(_checkStack_(1, PRMObject::prm_type::TYPE));
      DiscretizedVariable< double >* var = dynamic_cast< DiscretizedVariable< double >* >(t->_var_);
 
      if (!var) { GUM_ERROR(FatalError, "the current type's variable is not a LabelizedVariable.") }
 
      try {
        var->addTick(tick);
      } catch (DefaultInLabel const&) {
        GUM_ERROR(OperationNotAllowed, "tick already in used for this variable")
      }
    }

References _checkStack_(), gum::DiscretizedVariable< T_TICKS >::addTick(), GUM_ERROR, and gum::prm::PRMObject::TYPE.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildRealTypes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeCurrent()

template<GUM_Numeric GUM_SCALAR>

PRMObject * gum::prm::PRMFactory< GUM_SCALAR >::closeCurrent ( )

overridevirtual

Close current object being built.

Nothing is done in particular except removing the current object from the factory's stack. If the object was not added to a container it will not be deleted properly, so you might want to delete it yourself (at your own risks!).

Returns: Returns the top most object removed in this factory's stack before. If their is no such object, 0 is returned.

Implements gum::prm::IPRMFactory.

Definition at line 1351 of file PRMFactory_tpl.h.

                                                      {
      if (_stack_.size() > 0) {
        PRMObject* obj = _stack_.back();
        _stack_.pop_back();
        return obj;
      } else {
        return 0;
      }
    }

References _stack_.

◆ continueAggregator()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::continueAggregator ( std::string_view name )

Conitnues an aggregator declaration.

Definition at line 589 of file PRMFactory_tpl.h.

                                                                         {
      PRMClassElementContainer< GUM_SCALAR >* c = _checkStackContainter_(1);
 
      if (!c->exists(name)) GUM_ERROR(NotFound, "Element " << name << "not found")
 
      auto& agg = c->get(name);
      if (!PRMClassElement< GUM_SCALAR >::isAggregate(agg))
        GUM_ERROR(OperationNotAllowed, "Element " << name << " not an aggregate")
 
      _stack_.push_back(&agg);
    }

References _checkStackContainter_(), _stack_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAggregates_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continueAttribute()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::continueAttribute ( std::string_view name )

overridevirtual

Continues the declaration of an attribute.

Implements gum::prm::IPRMFactory.

Definition at line 1548 of file PRMFactory_tpl.h.

                                                                        {
      PRMClassElementContainer< GUM_SCALAR >* c = _checkStackContainter_(1);
 
      if (!c->exists(name)) GUM_ERROR(NotFound, "Attribute " << name << "not found")
 
      auto& a = c->get(name);
 
      if (!PRMClassElement< GUM_SCALAR >::isAttribute(a))
        GUM_ERROR(OperationNotAllowed, "Element " << name << " not an attribute")
 
      _stack_.push_back(&a);
    }

References _checkStackContainter_(), _stack_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAttribute_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continueClass()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::continueClass ( std::string_view c )

overridevirtual

Continue the declaration of a class.

Implements gum::prm::IPRMFactory.

Definition at line 102 of file PRMFactory_tpl.h.

                                                                    {
      std::string real_name = _addPrefix_(name);
      if (!(_prm_->_classMap_.exists(real_name))) {
        GUM_ERROR(NotFound, std::format("'{}' not found", real_name))
      }
      _stack_.push_back(&(_prm_->getClass(real_name)));
    }

References _addPrefix_(), _prm_, _stack_, and GUM_ERROR.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_addReferenceSlots_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAggregates_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAttribute_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildParameters(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttributes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continueInterface()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::continueInterface ( std::string_view name )

overridevirtual

Continue the declaration of an interface.

Implements gum::prm::IPRMFactory.

Definition at line 216 of file PRMFactory_tpl.h.

                                                                        {
      std::string real_name = _addPrefix_(name);
      if (!_prm_->_interfaceMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, "'" << real_name << "' not found.")
      }
 
      PRMInterface< GUM_SCALAR >* i = _retrieveInterface_(real_name);
      _stack_.push_back(i);
    }

References _addPrefix_(), _prm_, _retrieveInterface_(), _stack_, and GUM_ERROR.

Referenced by gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ currentPackage()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::PRMFactory< GUM_SCALAR >::currentPackage ( ) const

overridevirtual

Returns: Returns the current package name.

Implements gum::prm::IPRMFactory.

Definition at line 1362 of file PRMFactory_tpl.h.

                                                             {
      return (_packages_.empty()) ? "" : _packages_.back();
    }

References _packages_.

Referenced by _retrieveType_(), and popPackage().

Here is the caller graph for this function:

◆ currentType()

template<GUM_Numeric GUM_SCALAR>

PRMObject::prm_type gum::prm::PRMFactory< GUM_SCALAR >::currentType ( ) const

overridevirtual

Returns: Returns the PRMObject type of the object begin built.

Exceptions

NotFound if no type is being built.

Implements gum::prm::IPRMFactory.

Definition at line 1330 of file PRMFactory_tpl.h.

                                                                  {
      if (_stack_.size() == 0) { GUM_ERROR(NotFound, "no object being built") }
 
      return _stack_.back()->obj_type();
    }

References _stack_, and GUM_ERROR.

Referenced by addNoisyOrCompound().

Here is the caller graph for this function:

◆ endAggregator()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endAggregator ( )

Finishes an aggregate declaration.

Definition at line 659 of file PRMFactory_tpl.h.

                                                 {
      _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_aggregate);
      _stack_.pop_back();
    }

References _checkStack_(), _stack_, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAggregates_(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAggregates_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endAttribute()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endAttribute ( )

overridevirtual

Tells the factory that we finished declaring an attribute.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1562 of file PRMFactory_tpl.h.

                                                {
      _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute);
      _stack_.pop_back();
    }

References _checkStack_(), _stack_, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAttribute_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAttribute_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), and addAttribute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endClass()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endClass ( bool checkImplementations = true )

overridevirtual

Tells the factory that we finished a class declaration.

Exceptions

PRMTypeError Raised if the current Class<GUM_SCALAR> does not respect one of it's PRMInterface<GUM_SCALAR>.

Implements gum::prm::IPRMFactory.

Definition at line 111 of file PRMFactory_tpl.h.

                                                                     {
      PRMClass< GUM_SCALAR >* c
          = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
 
      if (checkImplementations) { _checkInterfaceImplementation_(c); }
 
      _stack_.pop_back();
    }

References _checkInterfaceImplementation_(), _checkStack_(), _stack_, and gum::prm::PRMObject::CLASS.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_addReferenceSlots_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAggregates_(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAttribute_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), addInstance(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildClasses(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildParameters(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttributes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endDiscreteType()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType ( )

overridevirtual

End the current discrete type declaration.

Exceptions

OperationNotAllowed Raised if the current type is not a valid discrete type.

Implements gum::prm::IPRMFactory.

Definition at line 1433 of file PRMFactory_tpl.h.

                                                   {
      PRMType* t = static_cast< PRMType* >(_checkStack_(1, PRMObject::prm_type::TYPE));
 
      if (!t->_isValid_()) {
        GUM_ERROR(OperationNotAllowed, "current type is not a valid subtype")
      } else if (t->variable().domainSize() < 2) {
        GUM_ERROR(OperationNotAllowed, "current type is not a valid discrete type")
      }
 
      _prm_->_typeMap_.insert(t->name(), t);
 
      _prm_->_types_.insert(t);
      _stack_.pop_back();
    }

References _checkStack_(), _prm_, _stack_, gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Variable::name(), and gum::prm::PRMObject::TYPE.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildTypes_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateType_(), and gum::prm::LayerGenerator< GUM_SCALAR >::_generateType_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endDiscretizedType()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endDiscretizedType ( )

overridevirtual

End the current discretized type declaration.

Exceptions

OperationNotAllowed Raised if the current type is not a valid discrete type.

Implements gum::prm::IPRMFactory.

Definition at line 1474 of file PRMFactory_tpl.h.

                                                      {
      PRMType* t = static_cast< PRMType* >(_checkStack_(1, PRMObject::prm_type::TYPE));
 
      if (t->variable().domainSize() < 2) {
        GUM_ERROR(OperationNotAllowed, "current type is not a valid discrete type")
      }
 
      _prm_->_typeMap_.insert(t->name(), t);
 
      _prm_->_types_.insert(t);
      _stack_.pop_back();
    }

References _checkStack_(), _prm_, _stack_, gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Variable::name(), and gum::prm::PRMObject::TYPE.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildRealTypes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endInterface()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endInterface ( )

overridevirtual

Tells the factory that we finished an interface declaration.

Implements gum::prm::IPRMFactory.

Definition at line 1506 of file PRMFactory_tpl.h.

                                                {
      _checkStack_(1, PRMObject::prm_type::PRM_INTERFACE);
      _stack_.pop_back();
    }

References _checkStack_(), _stack_, and gum::prm::PRMObject::PRM_INTERFACE.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateInterfaces_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateInterfaces_(), gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildElements(), and gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildInterfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endSystem()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::endSystem ( )

overridevirtual

Tells the factory that we finished declaring a model.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1579 of file PRMFactory_tpl.h.

                                             {
      try {
        PRMSystem< GUM_SCALAR >* model
            = static_cast< PRMSystem< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::SYSTEM));
        _stack_.pop_back();
        model->instantiate();
      } catch (Exception const&) { GUM_ERROR(FatalError, "could not create system") }
    }

References _checkStack_(), _stack_, GUM_ERROR, gum::prm::PRMSystem< GUM_SCALAR >::instantiate(), and gum::prm::PRMObject::SYSTEM.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_(), and gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::build().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCurrent() [1/2]

template<GUM_Numeric GUM_SCALAR>

const PRMObject * gum::prm::PRMFactory< GUM_SCALAR >::getCurrent ( ) const

overridevirtual

Returns a pointer on the PRM<GUM_SCALAR> created by this factory.

This pointer will not be deleted when the factory is destroyed.

Returns: Returns the PRM<GUM_SCALAR> created by this factory.

Implements gum::prm::IPRMFactory.

Definition at line 1344 of file PRMFactory_tpl.h.

                                                                {
      if (_stack_.size() == 0) { GUM_ERROR(NotFound, "no object being built") }
 
      return _stack_.back();
    }

References _stack_, and GUM_ERROR.

◆ getCurrent() [2/2]

template<GUM_Numeric GUM_SCALAR>

PRMObject * gum::prm::PRMFactory< GUM_SCALAR >::getCurrent ( )

overridevirtual

Returns: the current PRMObject being built by this factory.

Exceptions

NotFound if nothing is being built.

Implements gum::prm::IPRMFactory.

Definition at line 1337 of file PRMFactory_tpl.h.

                                                    {
      if (_stack_.size() == 0) { GUM_ERROR(NotFound, "no object being built") }
 
      return _stack_.back();
    }

References _stack_, and GUM_ERROR.

Referenced by addNoisyOrCompound(), and isArrayInCurrentSystem().

Here is the caller graph for this function:

◆ incArray()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::incArray	(	std::string_view	l_i,
		std::string_view	r_i )

overridevirtual

Add an instance to an array.

Implements gum::prm::IPRMFactory.

Definition at line 876 of file PRMFactory_tpl.h.

                                                                                  {
      PRMSystem< GUM_SCALAR >* model
          = static_cast< PRMSystem< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::SYSTEM));
 
      if (model->isArray(std::string(l_i))) {
        if (model->isInstance(std::string(r_i))) {
          model->add(std::string(l_i), model->get(r_i));
        } else {
          GUM_ERROR(NotFound, "right value is not an instance")
        }
      } else {
        GUM_ERROR(NotFound, "left value is no an array")
      }
    }

References _checkStack_(), gum::prm::PRMSystem< GUM_SCALAR >::add(), gum::prm::PRMSystem< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMSystem< GUM_SCALAR >::isArray(), gum::prm::PRMSystem< GUM_SCALAR >::isInstance(), and gum::prm::PRMObject::SYSTEM.

Here is the call graph for this function:

◆ isArrayInCurrentSystem()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMFactory< GUM_SCALAR >::isArrayInCurrentSystem ( std::string_view name ) const

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1836 of file PRMFactory_tpl.h.

                                                                                   {
      const PRMSystem< GUM_SCALAR >* system
          = static_cast< const PRMSystem< GUM_SCALAR >* >(getCurrent());
      return (system && system->isArray(name));
    }

References getCurrent(), and gum::prm::PRMSystem< GUM_SCALAR >::isArray().

Here is the call graph for this function:

◆ isClassOrInterface()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMFactory< GUM_SCALAR >::isClassOrInterface ( std::string_view type ) const

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1817 of file PRMFactory_tpl.h.

                                                                               {
      try {
        _retrieveClass_(type);
        return true;
 
      } catch (NotFound const&) {
      } catch (DuplicateElement const&) {}
 
      try {
        _retrieveInterface_(type);
        return true;
 
      } catch (NotFound const&) {
      } catch (DuplicateElement const&) {}
 
      return false;
    }

References _retrieveClass_(), and _retrieveInterface_().

Here is the call graph for this function:

◆ operator=()

template<GUM_Numeric GUM_SCALAR>

PRMFactory & gum::prm::PRMFactory< GUM_SCALAR >::operator= ( const PRMFactory< GUM_SCALAR > & from )

delete

Copy operator. Don't use it.

References PRMFactory().

Here is the call graph for this function:

◆ popPackage()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::PRMFactory< GUM_SCALAR >::popPackage ( )

overridevirtual

Pop the current package from the package stack.

Returns: the popped package or an empty string if there was nothing to pop.

Implements gum::prm::IPRMFactory.

Definition at line 1766 of file PRMFactory_tpl.h.

                                                   {
      std::string plop = currentPackage();
 
      if (!_packages_.empty()) {
        std::string s = _packages_.back();
        _packages_.pop_back();
 
        if (_namespaces_.size() > 0) {
          delete _namespaces_.back();
          _namespaces_.pop_back();
        }
        return s;
      }
 
      return plop;
    }

References _namespaces_, _packages_, and currentPackage().

Here is the call graph for this function:

◆ prm()

template<GUM_Numeric GUM_SCALAR>

PRM< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::prm ( ) const

Returns a pointer on the PRM<GUM_SCALAR> created by this factory.

This pointer will not be deleted when the factory is destroyed.

Returns: Returns the PRM<GUM_SCALAR> created by this factory.

Definition at line 1325 of file PRMFactory_tpl.h.

                                                           {
      return _prm_;
    }

References _prm_.

Referenced by PRMFactory(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::generate(), and gum::prm::LayerGenerator< GUM_SCALAR >::generate().

Here is the caller graph for this function:

◆ pushPackage()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::pushPackage ( std::string_view name )

overridevirtual

Define the current package.

A stack is used to keep track of packages given the different imports.

Parameters

name	The name of the package for all further objects.

Implements gum::prm::IPRMFactory.

Definition at line 1760 of file PRMFactory_tpl.h.

                                                                  {
      _packages_.emplace_back(name);
      _namespaces_.push_back(new List< std::string >());
    }

References _namespaces_, and _packages_.

◆ retrieveClass()

template<GUM_Numeric GUM_SCALAR>

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

Returns a reference over a Class<GUM_SCALAR> given its name.

This methods adds if necessary the current package as a prefix to name.

Parameters

name	The name of the Class<GUM_SCALAR>.

Returns: the Class<GUM_SCALAR> with the given name.

Exceptions

NotFound if no Class<GUM_SCALAR> matches the given name.

Definition at line 1801 of file PRMFactory_tpl.h.

                                                                                       {
      return *_retrieveClass_(name);
    }

References _retrieveClass_().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ retrieveCommonType()

template<GUM_Numeric GUM_SCALAR>

PRMType & gum::prm::PRMFactory< GUM_SCALAR >::retrieveCommonType ( const std::vector< PRMClassElement< GUM_SCALAR > * > & elts )

Returns a pointer on the PRM<GUM_SCALAR> created by this factory.

This pointer will not be deleted when the factory is destroyed.

Returns: Returns the PRM<GUM_SCALAR> created by this factory.

Definition at line 1811 of file PRMFactory_tpl.h.

                                                                 {
      return *(_retrieveCommonType_(elts));
    }

References _retrieveCommonType_().

Here is the call graph for this function:

◆ retrieveType()

template<GUM_Numeric GUM_SCALAR>

PRMType & gum::prm::PRMFactory< GUM_SCALAR >::retrieveType ( std::string_view name )

Returns a reference over a PRMType given its name.

This methods adds if necessary the current package as a prefix to name.

Parameters

name	The name of the PRMType.

Returns: the PRMType with the given name.

Exceptions

NotFound if no PRMType matches the given name.

Definition at line 1806 of file PRMFactory_tpl.h.

                                                                       {
      return *_retrieveType_(name);
    }

References _retrieveType_().

Referenced by addNoisyOrCompound().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCPFByFloatRule()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setCPFByFloatRule	(	const std::vector< std::string > &	labels,
		const std::vector< float > &	values )

overridevirtual

Fills the CPF using a rule.

The labels vector is filled with one of each parent's labels or with a wildcard ("*"). If a wildcard is used then all values of the corresponding parents are used. The sequence of parents must be the declaration order used when adding the current attribute's parents.

Parameters

labels	The value of each parents.
values	The probability values of the current attribute given the values in parenst.

Implements gum::prm::IPRMFactory.

Definition at line 388 of file PRMFactory_tpl.h.

                                                                                             {
      auto a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if ((parents.size() + 1) != a->cpf().variablesSequence().size()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of parents")
      }
 
      if (values.size() != a->type().variable().domainSize()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of values")
      }
 
      std::vector< GUM_SCALAR > values2(values.begin(), values.end());
      setCPFByRule(parents, values2);
    }

References _checkStack_(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, and setCPFByRule().

Here is the call graph for this function:

◆ setCPFByRule() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setCPFByRule	(	const std::vector< std::string > &	labels,
		const std::vector< GUM_SCALAR > &	values )

virtual

Fills the CPF using a rule.

The labels vector is filled with one of each parent's labels or with a wildcard ("*"). If a wildcard is used then all values of the corresponding parents are used. The sequence of parents must be the declaration order used when adding the current attribute's parents.

Parameters

labels	The value of each parents.
values	The probability values of the current attribute given the values in parents.

Definition at line 406 of file PRMFactory_tpl.h.

                                                                                        {
      auto a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if ((parents.size() + 1) != a->cpf().variablesSequence().size()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of parents")
      }
 
      if (values.size() != a->type().variable().domainSize()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of values")
      }
 
      if (dynamic_cast< PRMFormAttribute< GUM_SCALAR >* >(a)) {
        auto form = static_cast< PRMFormAttribute< GUM_SCALAR >* >(a);
        // jnst holds parents with a specific value (not "*")
        // knst holds parents without a specific value ("*")
        Instantiation           jnst, knst;
        const DiscreteVariable* var = 0;
        // not_used Size pos = 0;
        bool found = false;
 
        for (Idx i = 0; i < parents.size(); ++i) {
          var = form->formulas().variablesSequence().atPos(1 + i);
 
          if (parents[i] == "*") {
            knst.add(*var);
          } else {
            jnst.add(*var);
            // not_used pos = 0;
            found = false;
 
            for (Size j = 0; j < var->domainSize(); ++j) {
              if (var->label(j) == parents[i]) {
                jnst.chgVal(*var, j);
                found = true;
                break;
              }
            }
 
            if (!found) {
              std::string msg = "could not find label ";
              GUM_ERROR(NotFound, msg + parents[i])
            }
          }
        }
 
        Instantiation inst(form->formulas());
        inst.setVals(jnst);
 
        for (Size i = 0; i < form->type()->domainSize(); ++i) {
          inst.chgVal(form->type().variable(), i);
 
          for (inst.setFirstIn(knst); !inst.end(); inst.incIn(knst)) {
            form->formulas().set(inst, std::to_string(values[i]));
          }
        }
 
      } else {
        GUM_ERROR(OperationNotAllowed, "invalide attribute type")
      }
    }

References _checkStack_(), gum::Instantiation::chgVal(), gum::DiscreteVariable::domainSize(), gum::Instantiation::end(), GUM_ERROR, gum::Instantiation::incIn(), gum::DiscreteVariable::label(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::Instantiation::setFirstIn(), and gum::Instantiation::setVals().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAttribute_(), and setCPFByFloatRule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCPFByRule() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setCPFByRule	(	const std::vector< std::string > &	labels,
		const std::vector< std::string > &	values )

overridevirtual

Fills the CPF using a rule and gum::Formula.

The labels vector is filled with one of each parent's labels or with a wildcard ("*"). If a wildcard is used then all values of the corresponding parents are used. The sequence of parents must be the declaration order used when adding the current attribute's parents.

Parameters

labels	The value of each parents.
values	The probability values of the current attribute given the values in parents.

Implements gum::prm::IPRMFactory.

Definition at line 470 of file PRMFactory_tpl.h.

                                                                                      {
      auto a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if ((parents.size() + 1) != a->cpf().variablesSequence().size()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of parents")
      }
 
      if (values.size() != a->type().variable().domainSize()) {
        GUM_ERROR(OperationNotAllowed, "wrong number of values")
      }
 
      if (dynamic_cast< PRMFormAttribute< GUM_SCALAR >* >(a)) {
        auto form = static_cast< PRMFormAttribute< GUM_SCALAR >* >(a);
        // jnst holds parents with a specific value (not "*")
        // knst holds parents without a specific value ("*")
        Instantiation           jnst, knst;
        const DiscreteVariable* var = 0;
        // not_used Size pos = 0;
        bool found = false;
 
        for (Idx i = 0; i < parents.size(); ++i) {
          var = form->formulas().variablesSequence().atPos(1 + i);
 
          if (parents[i] == "*") {
            knst.add(*var);
          } else {
            jnst.add(*var);
            // not_used pos = 0;
            found = false;
 
            for (Size j = 0; j < var->domainSize(); ++j) {
              if (var->label(j) == parents[i]) {
                jnst.chgVal(*var, j);
                found = true;
                break;
              }
            }
 
            if (!found) {
              std::string msg = "could not find label ";
              GUM_ERROR(NotFound, msg + parents[i])
            }
          }
        }
 
        Instantiation inst(form->formulas());
        inst.setVals(jnst);
 
        for (Size i = 0; i < form->type()->domainSize(); ++i) {
          inst.chgVal(form->type().variable(), i);
 
          for (inst.setFirstIn(knst); !inst.end(); inst.incIn(knst)) {
            form->formulas().set(inst, values[i]);
          }
        }
 
      } else {
        GUM_ERROR(OperationNotAllowed, "invalide attribute type")
      }
    }

References _checkStack_(), gum::Instantiation::chgVal(), gum::DiscreteVariable::domainSize(), gum::Instantiation::end(), GUM_ERROR, gum::Instantiation::incIn(), gum::DiscreteVariable::label(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::Instantiation::setFirstIn(), and gum::Instantiation::setVals().

Here is the call graph for this function:

◆ setRawCPFByColumns() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns ( const std::vector< GUM_SCALAR > & array )

Gives the factory the CPF in its raw form.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

//P(A|f,f),P(A|f,t),P(A|t,f),P(A|t,t)
[ 0.2,     0.7,     0.5,     0.01,
  0.8,     0.3,     0.5,     0.99]

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Definition at line 357 of file PRMFactory_tpl.h.

                                                                                          {
      PRMAttribute< GUM_SCALAR >* a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if (a->cpf().domainSize() != array.size()) {
        GUM_ERROR(OperationNotAllowed, "illegal CPF size")
      }
 
      if (a->cpf().nbrDim() == 1) {
        setRawCPFByLines(array);
 
      } else {
        Instantiation inst(a->cpf());
        Instantiation jnst;
        for (auto idx = inst.variablesSequence().rbegin(); idx != inst.variablesSequence().rend();
             --idx) {
          jnst.add(**idx);
        }
 
        jnst.setFirst();
        auto idx = (std::size_t)0;
        while ((!jnst.end()) && idx < array.size()) {
          inst.setVals(jnst);
          a->cpf().set(inst, array[idx]);
          jnst.inc();
          ++idx;
        }
      }
    }

References _checkStack_(), gum::Instantiation::add(), gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), gum::Instantiation::end(), GUM_ERROR, gum::Instantiation::inc(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::Instantiation::setFirst(), setRawCPFByLines(), gum::Instantiation::setVals(), and gum::Instantiation::variablesSequence().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_completeAttribute_(), and setRawCPFByFloatColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setRawCPFByColumns() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns ( const std::vector< std::string > & array )

overridevirtual

Gives the factory the CPF in its raw form use gum::Formula.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

//P(A|f,f),P(A|f,t),P(A|t,f),P(A|t,t)
[ 0.2,     0.7,     0.5,     0.01,
  0.8,     0.3,     0.5,     0.99]

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1843 of file PRMFactory_tpl.h.

                                                                                         {
      _checkStack_(2, PRMObject::prm_type::CLASS);
 
      auto a = static_cast< PRMFormAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if (a->formulas().domainSize() != array.size()) {
        GUM_ERROR(OperationNotAllowed, "illegal CPF size")
      }
 
      if (a->formulas().nbrDim() == 1) {
        setRawCPFByLines(array);
 
      } else {
        Instantiation inst(a->formulas());
        Instantiation jnst;
        for (auto idx = inst.variablesSequence().rbegin(); idx != inst.variablesSequence().rend();
             --idx) {
          jnst.add(**idx);
        }
 
        jnst.setFirst();
        auto idx = (std::size_t)0;
        while ((!jnst.end()) && idx < array.size()) {
          inst.setVals(jnst);
          a->formulas().set(inst, array[idx]);
          jnst.inc();
          ++idx;
        }
 
        // Generate cpf by calling it
        a->cpf();
      }
    }

References _checkStack_(), gum::Instantiation::add(), gum::prm::PRMObject::CLASS, gum::Instantiation::end(), GUM_ERROR, gum::Instantiation::inc(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::Instantiation::setFirst(), setRawCPFByLines(), gum::Instantiation::setVals(), and gum::Instantiation::variablesSequence().

Here is the call graph for this function:

◆ setRawCPFByFloatColumns()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByFloatColumns ( const std::vector< float > & array )

overridevirtual

Gives the factory the CPF in its raw form.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

//P(A|f,f),P(A|f,t),P(A|t,f),P(A|t,t)
[ 0.2,     0.7,     0.5,     0.01,
  0.8,     0.3,     0.5,     0.99]

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 344 of file PRMFactory_tpl.h.

                                                                                          {
      PRMAttribute< GUM_SCALAR >* a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if (a->cpf().domainSize() != array.size()) {
        GUM_ERROR(OperationNotAllowed, "illegal CPF size")
      }
 
      std::vector< GUM_SCALAR > array2(array.begin(), array.end());
      setRawCPFByColumns(array2);
    }

References _checkStack_(), gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, and setRawCPFByColumns().

Here is the call graph for this function:

◆ setRawCPFByFloatLines()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByFloatLines ( const std::vector< float > & array )

overridevirtual

Gives the factory the CPF in its raw form.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

[0.20, 0.80, // P(f|f, f) = 0.20 and P(t|f, f) = 0.80
50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
01, 0.99] // P(f|t, t) = 0.01 and P(t|t, t) = 0.99

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 319 of file PRMFactory_tpl.h.

                                                                                        {
      PRMAttribute< GUM_SCALAR >* a = static_cast< PRMAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
      _checkStack_(2, PRMObject::prm_type::CLASS);
 
      if (a->cpf().domainSize() != array.size()) GUM_ERROR(OperationNotAllowed, "illegal CPF size")
 
      std::vector< GUM_SCALAR > array2(array.begin(), array.end());
      a->cpf().fillWith(array2);
    }

References _checkStack_(), gum::prm::PRMObject::CLASS, gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Here is the call graph for this function:

◆ setRawCPFByLines() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines ( const std::vector< GUM_SCALAR > & array )

Gives the factory the CPF in its raw form.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

[0.20, 0.80, // P(f|f, f) = 0.20 and P(t|f, f) = 0.80
50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
01, 0.99] // P(f|t, t) = 0.01 and P(t|t, t) = 0.99

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Definition at line 331 of file PRMFactory_tpl.h.

                                                                                        {
      auto elt = _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute);
      auto a   = static_cast< PRMAttribute< GUM_SCALAR >* >(elt);
      _checkStack_(2, PRMObject::prm_type::CLASS);
 
      if (a->cpf().domainSize() != array.size()) {
        GUM_ERROR(OperationNotAllowed, "illegal CPF size")
      }
 
      a->cpf().fillWith(array);
    }

References _checkStack_(), gum::prm::PRMObject::CLASS, GUM_ERROR, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), setRawCPFByColumns(), and setRawCPFByColumns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setRawCPFByLines() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines ( const std::vector< std::string > & array )

overridevirtual

Gives the factory the CPF in its raw form using gum::Formula.

The creation of the CPF is left to the factory because we do not know what level of complexity for CPF implementation can be handled by the PRM<GUM_SCALAR> implementation.

How to fill a CPT? If you want to fill the CPT of P(A|B,C) with A, B and C boolean variables ( {f, t}, the order is important), then the following array is valid:

[0.20, 0.80, // P(f|f, f) = 0.20 and P(t|f, f) = 0.80
50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
01, 0.99] // P(f|t, t) = 0.01 and P(t|t, t) = 0.99

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1879 of file PRMFactory_tpl.h.

                                                                                       {
      _checkStack_(2, PRMObject::prm_type::CLASS);
 
      auto a = static_cast< PRMFormAttribute< GUM_SCALAR >* >(
          _checkStack_(1, PRMClassElement< GUM_SCALAR >::prm_attribute));
 
      if (a->formulas().domainSize() != array.size()) {
        GUM_ERROR(OperationNotAllowed, "illegal CPF size")
      }
 
      a->formulas().populate(array);
      a->cpf();
    }

References _checkStack_(), gum::prm::PRMObject::CLASS, gum::prm::PRMFormAttribute< GUM_SCALAR >::formulas(), GUM_ERROR, gum::MultiDimContainer< GUM_ELEMENT >::populate(), and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Here is the call graph for this function:

◆ setReferenceSlot() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot	(	std::string_view	l_i,
		std::string_view	r_i )

overridevirtual

Instantiate a reference in the current model.

This is equivalent to the following SKOOL instruction: left_instance.left_reference = right_instance;

right_instance's type must be compatible with the slot type of left_reference.

Parameters

l_i	A slot chain starting from an instance and ending over a reference slot.
r_i	The name of an instance or an array of instances in the model.

Implements gum::prm::IPRMFactory.

Definition at line 1791 of file PRMFactory_tpl.h.

                                                                                          {
      if (auto pos = l_i.find_last_of('.'); pos != std::string_view::npos) {
        std::string_view l_ref = l_i.substr(pos + 1);
        setReferenceSlot(l_i.substr(0, pos), l_ref, r_i);
      } else {
        GUM_ERROR(NotFound, "left value does not name an instance or an array")
      }
    }

References GUM_ERROR, and setReferenceSlot().

Here is the call graph for this function:

◆ setReferenceSlot() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot	(	std::string_view	left_instance,
		std::string_view	left_reference,
		std::string_view	right_instance )

overridevirtual

Instantiate a reference in the current model.

This is equivalent to the following SKOOL instruction: left_instance.left_reference = right_instance;

right_instance's type must be compatible with the slot type of left_reference.

Parameters

left_instance	The name of an instance in the model.
left_reference	The name of a reference of left_instance.
right_instance	The name of an instance or an array of instances in the model.

Implements gum::prm::IPRMFactory.

Definition at line 892 of file PRMFactory_tpl.h.

                                                                        {
      auto model
          = static_cast< PRMSystem< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::SYSTEM));
      std::vector< PRMInstance< GUM_SCALAR >* > lefts;
      std::vector< PRMInstance< GUM_SCALAR >* > rights;
 
      if (model->isInstance(std::string(l_i))) {
        lefts.push_back(&(model->get(l_i)));
      } else if (model->isArray(std::string(l_i))) {
        for (const auto& elt: model->getArray(std::string(l_i)))
          lefts.push_back(elt);
      } else {
        GUM_ERROR(NotFound, "left value does not name an instance or an array")
      }
 
      if (model->isInstance(std::string(r_i))) {
        rights.push_back(&(model->get(r_i)));
      } else if (model->isArray(std::string(r_i))) {
        for (const auto& elt: model->getArray(std::string(r_i)))
          rights.push_back(elt);
      } else {
        GUM_ERROR(NotFound, "left value does not name an instance or an array")
      }
 
      for (const auto l: lefts) {
        for (const auto r: rights) {
          auto& elt = l->type().get(l_ref);
          if (PRMClassElement< GUM_SCALAR >::isReferenceSlot(elt)) {
            l->add(elt.id(), *r);
 
          } else {
            GUM_ERROR(NotFound, "unfound reference slot")
          }
        }
      }
    }

References _checkStack_(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::isReferenceSlot(), and gum::prm::PRMObject::SYSTEM.

Referenced by gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::_addAssignments_(), gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::_addIncrements_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_(), and setReferenceSlot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startAggregator()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startAggregator	(	std::string_view	name,
		std::string_view	agg_type,
		std::string_view	rv_type,
		const std::vector< std::string > &	params )

Start an aggregator declaration.

Parameters

name	The aggregator's name.
agg_type	The aggregtor's type (

See also: Aggregate::agg_type()).

Parameters

rv_type The aggregator's random variable type (

See also: Aggregate::type()).

Parameters

params The aggregator's parameters.

Definition at line 556 of file PRMFactory_tpl.h.

                                                                                         {
      PRMClass< GUM_SCALAR >* c
          = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
 
      auto agg = new PRMAggregate< GUM_SCALAR >(name,
                                                PRMAggregate< GUM_SCALAR >::str2enum(agg_type),
                                                *_retrieveType_(rv_type));
 
      try {
        c->add(agg);
      } catch (DuplicateElement const&) { c->overload(agg); }
 
      switch (agg->agg_type()) {
        case PRMAggregate< GUM_SCALAR >::AggregateType::COUNT :
        case PRMAggregate< GUM_SCALAR >::AggregateType::EXISTS :
        case PRMAggregate< GUM_SCALAR >::AggregateType::FORALL : {
          if (params.size() != 1) {
            GUM_ERROR(OperationNotAllowed, "aggregate requires a parameter")
          }
          agg->setLabel(params.front());
          break;
        }
        default : {
          // Nothing to do
        }
      }
      _stack_.push_back(agg);
    }

References _checkStack_(), _retrieveType_(), _stack_, gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMObject::CLASS, gum::prm::PRMAggregate< GUM_SCALAR >::COUNT, gum::prm::PRMAggregate< GUM_SCALAR >::EXISTS, gum::prm::PRMAggregate< GUM_SCALAR >::FORALL, GUM_ERROR, gum::prm::PRMClass< GUM_SCALAR >::overload(), and gum::prm::PRMAggregate< GUM_SCALAR >::str2enum().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAggregates_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startAttribute()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startAttribute	(	std::string_view	type,
		std::string_view	name,
		bool	scalar_atttr = false )

overridevirtual

Tells the factory that we start an attribute declaration.

Exceptions

FatalError Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1519 of file PRMFactory_tpl.h.

                                                                                {
      PRMClassElementContainer< GUM_SCALAR >* c = _checkStackContainter_(1);
      PRMAttribute< GUM_SCALAR >*             a = nullptr;
 
      if (PRMObject::isClass(*c) && (!scalar_attr)) {
        a = new PRMFormAttribute< GUM_SCALAR >(static_cast< PRMClass< GUM_SCALAR >& >(*c),
                                               name,
                                               *_retrieveType_(type));
 
      } else {
        a = new PRMScalarAttribute< GUM_SCALAR >(name, *_retrieveType_(type));
      }
 
      std::string dot = ".";
 
      try {
        try {
          c->add(a);
        } catch (DuplicateElement const&) { c->overload(a); }
      } catch (Exception const&) {
        if (a != nullptr && (!c->exists(a->id()))) { delete a; }
      }
 
      _stack_.push_back(a);
    }

References _checkStackContainter_(), _retrieveType_(), _stack_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::add(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::isClass(), and gum::prm::PRMClassElementContainer< GUM_SCALAR >::overload().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_declareAttribute_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), and addAttribute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startClass()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startClass	(	std::string_view	c,
		std::string_view	ext = "",
		const Set< std::string > *	implements = nullptr,
		bool	delayInheritance = false )

overridevirtual

Tells the factory that we start a class declaration.

Use the default values if you do not want c to be a subclass or to implement interfaces.

Parameters

c	The class name.
ext	The name of the super class of c.
implements	The list of interface implemented by c.
delayInheritance	If true, the created gum::prm::Class inheritance will be delayed.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 66 of file PRMFactory_tpl.h.

                                                                                          {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_classMap_.exists(real_name) || _prm_->_interfaceMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, "'" << real_name << "' is already used.")
      }
      PRMClass< GUM_SCALAR >*            c      = nullptr;
      PRMClass< GUM_SCALAR >*            mother = nullptr;
      Set< PRMInterface< GUM_SCALAR >* > impl;
 
      if (implements != 0) {
        for (const auto& imp: *implements) {
          impl.insert(_retrieveInterface_(imp));
        }
      }
 
      if (extends != "") { mother = _retrieveClass_(extends); }
 
      if ((extends.empty()) && impl.empty()) {
        c = new PRMClass< GUM_SCALAR >(real_name);
      } else if ((extends != "") && impl.empty()) {
        c = new PRMClass< GUM_SCALAR >(real_name, *mother, delayInheritance);
      } else if ((extends.empty()) && (!impl.empty())) {
        c = new PRMClass< GUM_SCALAR >(real_name, impl, delayInheritance);
      } else if ((extends != "") && (!impl.empty())) {
        c = new PRMClass< GUM_SCALAR >(real_name, *mother, impl, delayInheritance);
      }
 
      _prm_->_classMap_.insert(c->name(), c);
      _prm_->_classes_.insert(c);
      _stack_.push_back(c);
    }

References _addPrefix_(), _prm_, _retrieveClass_(), _retrieveInterface_(), _stack_, gum::Set< Key >::empty(), GUM_ERROR, gum::Set< Key >::insert(), and gum::prm::PRMObject::name().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_(), addInstance(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildClasses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startDiscreteType()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType	(	std::string_view	name,
		std::string_view	super = "" )

overridevirtual

Start a discrete subtype declaration.

Parameters

name	The discrete type's name.
super	The super type of the declared discrete type.

Exceptions

DuplicateElement Raised if an object with the same name already exists.

Implements gum::prm::IPRMFactory.

Definition at line 1367 of file PRMFactory_tpl.h.

                                                                           {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_typeMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, "'" << real_name << "' is already used.")
      }
      if (super.empty()) {
        auto t = new PRMType(LabelizedVariable(real_name, "", 0));
        _stack_.push_back(t);
      } else {
        auto t         = new PRMType(LabelizedVariable(real_name, "", 0));
        t->_superType_ = _retrieveType_(super);
        t->_label_map_ = new std::vector< Idx >();
        _stack_.push_back(t);
      }
    }

References _addPrefix_(), _prm_, _retrieveType_(), _stack_, and GUM_ERROR.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildTypes_(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateType_(), and gum::prm::LayerGenerator< GUM_SCALAR >::_generateType_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startDiscretizedType()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startDiscretizedType ( std::string_view name )

overridevirtual

Start a discretized type declaration.

Parameters

name	The discretized type's name.

Exceptions

DuplicateElement Raised if an object with the same name already exists.

Implements gum::prm::IPRMFactory.

Definition at line 1449 of file PRMFactory_tpl.h.

                                                                           {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_typeMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, "'" << real_name << "' is already used.")
      }
      auto var = DiscretizedVariable< double >(real_name, "");
      auto t   = new PRMType(var);
      _stack_.push_back(t);
    }

References _addPrefix_(), _prm_, _stack_, and GUM_ERROR.

Referenced by gum::prm::o3prm::O3TypeFactory< GUM_SCALAR >::_buildRealTypes_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startInterface()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startInterface	(	std::string_view	i,
		std::string_view	ext = "",
		bool	delayInheritance = false )

overridevirtual

Tells the factory that we start an interface declaration.

Use the default values if you do not want c to be a subclass or to implement interfaces.

Parameters

i	The interface name.
ext	The name of the super interface of i.
delayInheritance	If true, the created gum::prm::PRMInterface inheritance will be delayed.

Exceptions

NotFound Raised if ext does not match any declared PRMInterface<GUM_SCALAR>.

Implements gum::prm::IPRMFactory.

Definition at line 192 of file PRMFactory_tpl.h.

                                                                                     {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_classMap_.exists(real_name) || _prm_->_interfaceMap_.exists(real_name)) {
        GUM_ERROR(DuplicateElement, "'" << real_name << "' is already used.")
      }
      PRMInterface< GUM_SCALAR >* i     = nullptr;
      PRMInterface< GUM_SCALAR >* super = nullptr;
 
      if (extends != "") { super = _retrieveInterface_(extends); }
 
      if (super != nullptr) {
        i = new PRMInterface< GUM_SCALAR >(real_name, *super, delayInheritance);
      } else {
        i = new PRMInterface< GUM_SCALAR >(real_name);
      }
 
      _prm_->_interfaceMap_.insert(i->name(), i);
      _prm_->_interfaces_.insert(i);
      _stack_.push_back(i);
    }

References _addPrefix_(), _prm_, _retrieveInterface_(), _stack_, GUM_ERROR, and gum::prm::PRMObject::name().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateInterfaces_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateInterfaces_(), and gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildInterfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ startSystem()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::startSystem ( std::string_view name )

overridevirtual

Tells the factory that we started declaring a model.

Exceptions

OperationNotAllowed Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1568 of file PRMFactory_tpl.h.

                                                                  {
      if (_prm_->_systemMap_.exists(name)) {
        GUM_ERROR(DuplicateElement, "'" << name << "' is already used.")
      }
      PRMSystem< GUM_SCALAR >* model = new PRMSystem< GUM_SCALAR >(_addPrefix_(name));
      _stack_.push_back(model);
      _prm_->_systemMap_.insert(model->name(), model);
      _prm_->_systems_.insert(model);
    }

References _addPrefix_(), _prm_, _stack_, GUM_ERROR, and gum::prm::PRMObject::name().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_(), gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_(), and gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::build().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _agg_params_

template<GUM_Numeric GUM_SCALAR>

HashTable< PRMAggregate< GUM_SCALAR >*, std::vector< std::string > > gum::prm::PRMFactory< GUM_SCALAR >::_agg_params_

private

A mapping between aggregators and their parameters.

Definition at line 1047 of file PRMFactory.h.

◆ _namespaces_

template<GUM_Numeric GUM_SCALAR>

std::vector< List< std::string >* > gum::prm::PRMFactory< GUM_SCALAR >::_namespaces_

private

Set of all declared namespaces.

Definition at line 1038 of file PRMFactory.h.

Referenced by ~PRMFactory(), _retrieveClass_(), _retrieveInterface_(), _retrieveType_(), addImport(), popPackage(), and pushPackage().

◆ _packages_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::string > gum::prm::PRMFactory< GUM_SCALAR >::_packages_

private

The prefix used for classes and types names. It is normally the namespace of the corresponding compilation unit.

Definition at line 1035 of file PRMFactory.h.

Referenced by _addPrefix_(), addInstance(), currentPackage(), popPackage(), and pushPackage().

◆ _prm_

template<GUM_Numeric GUM_SCALAR>

PRM< GUM_SCALAR >* gum::prm::PRMFactory< GUM_SCALAR >::_prm_

private

The pointer on the PRM<GUM_SCALAR> built by this factory.

Definition at line 1041 of file PRMFactory.h.

Referenced by PRMFactory(), PRMFactory(), _retrieveClass_(), _retrieveInterface_(), _retrieveType_(), addRangeType(), continueClass(), continueInterface(), endDiscreteType(), endDiscretizedType(), prm(), startClass(), startDiscreteType(), startDiscretizedType(), startInterface(), and startSystem().

◆ _stack_

template<GUM_Numeric GUM_SCALAR>

std::vector< PRMObject* > gum::prm::PRMFactory< GUM_SCALAR >::_stack_

private

A stack used to keep track of created PRMObject.

Definition at line 1044 of file PRMFactory.h.

Referenced by _checkStack_(), _checkStack_(), _checkStackContainter_(), closeCurrent(), continueAggregator(), continueAttribute(), continueClass(), continueInterface(), currentType(), endAggregator(), endAttribute(), endClass(), endDiscreteType(), endDiscretizedType(), endInterface(), endSystem(), getCurrent(), getCurrent(), startAggregator(), startAttribute(), startClass(), startDiscreteType(), startDiscretizedType(), startInterface(), and startSystem().

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

agrum/PRM/elements/PRMType.h
agrum/PRM/PRMFactory.h
agrum/PRM/PRMFactory_tpl.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PRMFactory() [1/3]

◆ PRMFactory() [2/3]

◆ PRMFactory() [3/3]

◆ ~PRMFactory()

Member Function Documentation

◆ _addInstance_()

◆ _addParent_() [1/2]

◆ _addParent_() [2/2]

◆ _addPrefix_()

◆ _buildAggregateCPF_()

◆ _buildSlotChain_()

◆ _checkInterfaceImplementation_()

◆ _checkStack_() [1/2]

◆ _checkStack_() [2/2]

◆ _checkStackContainter_()

◆ _instantiateSlotChain_()

◆ _retrieveClass_()

◆ _retrieveCommonType_()

◆ _retrieveInputs_()

◆ _retrieveInstanceSequence_()

◆ _retrieveInterface_()

◆ _retrieveType_()

◆ _typeDepth_()

◆ addAggregator()

◆ addArray()

◆ addAttribute() [1/2]

◆ addAttribute() [2/2]

◆ addImport()

◆ addInstance() [1/2]

◆ addInstance() [2/2]

◆ addLabel()

◆ addNoisyOrCompound()

◆ addParameter()

◆ addParent()

◆ addRangeType()

◆ addReferenceSlot()

◆ addTick()

◆ closeCurrent()

◆ continueAggregator()

◆ continueAttribute()

◆ continueClass()

◆ continueInterface()

◆ currentPackage()

◆ currentType()

◆ endAggregator()

◆ endAttribute()

◆ endClass()

◆ endDiscreteType()

◆ endDiscretizedType()

◆ endInterface()

◆ endSystem()

◆ getCurrent() [1/2]

◆ getCurrent() [2/2]

◆ incArray()

◆ isArrayInCurrentSystem()

◆ isClassOrInterface()

◆ operator=()

◆ popPackage()

◆ prm()

◆ pushPackage()

◆ retrieveClass()

◆ retrieveCommonType()

◆ retrieveType()

◆ setCPFByFloatRule()

◆ setCPFByRule() [1/2]

◆ setCPFByRule() [2/2]

◆ setRawCPFByColumns() [1/2]

◆ setRawCPFByColumns() [2/2]

◆ setRawCPFByFloatColumns()

◆ setRawCPFByFloatLines()

◆ setRawCPFByLines() [1/2]

◆ setRawCPFByLines() [2/2]

◆ setReferenceSlot() [1/2]

◆ setReferenceSlot() [2/2]

◆ startAggregator()