gum::prm::PRMFactory< GUM_SCALAR > Class Template Reference

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

Private Member Functions
Private methods for type checking and exception handling.
std::string	_addPrefix_ (const std::string &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_ (const std::string &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_ (const std::string &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_ (const std::string &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, const std::string &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, const std::string &name)
	Add a parent to an attribute.
void	_addParent_ (PRMClass< GUM_SCALAR > *c, PRMAggregate< GUM_SCALAR > *agg, const std::string &name)
	Add a parent to an aggregate.
Private methods handling PRMSystem<GUM_SCALAR> and
PRMInstance<GUM_SCALAR> creation.
void	_addInstance_ (PRMClass< GUM_SCALAR > *type, const std::string &name)
	Adds a 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<typename 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 88 of file PRMFactory.h.

Constructor & Destructor Documentation

PRMFactory() [1/3]

template<typename GUM_SCALAR>

INLINE gum::prm::PRMFactory< GUM_SCALAR >::PRMFactory

(

)

Default constructor.

Definition at line 1309 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<typename GUM_SCALAR>

INLINE 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 1315 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<typename 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<typename GUM_SCALAR>

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

virtual

Destructor.

Definition at line 1321 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::_addInstance_ ( PRMClass< GUM_SCALAR > * type, const std::string & name )

private

Adds a instance to the current model.

Definition at line 1676 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::_addParent_ ( PRMClass< GUM_SCALAR > * c, PRMAggregate< GUM_SCALAR > * agg, const std::string & name )

private

Add a parent to an aggregate.

Definition at line 608 of file PRMFactory_tpl.h.

                                                                                      {
      auto chains = std::vector< 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());
    }

References _retrieveInputs_(), _retrieveType_(), gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMAggregate< GUM_SCALAR >::agg_type(), gum::prm::PRMAggregate< GUM_SCALAR >::AMPLITUDE, gum::prm::PRMAggregate< GUM_SCALAR >::AND, gum::prm::PRMAggregate< GUM_SCALAR >::COUNT, gum::prm::PRMAggregate< GUM_SCALAR >::EXISTS, gum::prm::PRMAggregate< GUM_SCALAR >::FORALL, GUM_ERROR, gum::prm::PRMAggregate< GUM_SCALAR >::hasLabel(), gum::prm::PRMAggregate< GUM_SCALAR >::labelValue(), gum::prm::PRMAggregate< GUM_SCALAR >::MAX, gum::prm::PRMAggregate< GUM_SCALAR >::MEDIAN, gum::prm::PRMAggregate< GUM_SCALAR >::MIN, gum::prm::PRMAggregate< GUM_SCALAR >::OR, gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAggregate< GUM_SCALAR >::setLabel(), and gum::prm::PRMAggregate< GUM_SCALAR >::SUM.

Here is the call graph for this function:

_addParent_() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::_addParent_ ( PRMClassElementContainer< GUM_SCALAR > * c, PRMAttribute< GUM_SCALAR > * agg, const std::string & name )

private

Add a parent to an attribute.

Definition at line 253 of file PRMFactory_tpl.h.

                                                                             {
      try {
        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>")
          }
        }
      } catch (NotFound const&) {
        // Check if name is a slot chain
        PRMSlotChain< GUM_SCALAR >* sc = _buildSlotChain_(c, name);
 
        if (sc == nullptr) {
          std::string msg = "found no ClassElement<GUM_SCALAR> with the given name ";
          GUM_ERROR(NotFound, msg + 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>.");
        }
      }
    }

References _buildSlotChain_(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::add(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::addArc(), gum::prm::PRMClassElement< GUM_SCALAR >::elt_type(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMSlotChain< GUM_SCALAR >::isMultiple(), 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, and gum::prm::PRMClassElement< GUM_SCALAR >::prm_slotchain.

Referenced by addParent().

Here is the call graph for this function:

Here is the caller graph for this function:

_addPrefix_()

template<typename GUM_SCALAR>

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

private

Adds prefix to str iff prefix != "".

Definition at line 1692 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 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<typename 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<typename GUM_SCALAR>

INLINE PRMSlotChain< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_buildSlotChain_ ( PRMClassElementContainer< GUM_SCALAR > * start, const std::string & 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) {
        try {
          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;
            }
          }
        } catch (NotFound const&) { 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 >::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<typename GUM_SCALAR>

INLINE 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 {
        for (const auto& i: c->implements()) {
          try {
            for (const auto& node: i->containerDag().nodes()) {
              std::string name = i->get(node).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())) {
                      std::stringstream msg;
                      msg << "class " << c->name() << " does not respect interface ";
                      GUM_ERROR(PRMTypeError, msg.str() + i->name())
                    }
                  } else {
                    std::stringstream msg;
                    msg << "class " << c->name() << " does not respect interface ";
                    GUM_ERROR(PRMTypeError, msg.str() + 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())) {
                      std::stringstream msg;
                      msg << "class " << c->name() << " does not respect interface ";
                      GUM_ERROR(PRMTypeError, msg.str() + i->name())
                    }
                  } else {
                    std::stringstream msg;
                    msg << "class " << c->name() << " does not respect interface ";
                    GUM_ERROR(PRMTypeError, msg.str() + 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&) {
            std::stringstream msg;
            msg << "class " << c->name() << " does not respect interface ";
            GUM_ERROR(PRMTypeError, msg.str() + i->name())
          }
        }
      } catch (NotFound const&) {
        // this Class<GUM_SCALAR> does not implement any
        // PRMInterface<GUM_SCALAR>
      }
    }

References 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<typename GUM_SCALAR>

INLINE 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 1704 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<typename GUM_SCALAR>

INLINE 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 1738 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<typename GUM_SCALAR>

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

private

Adds prefix to str iff prefix != "".

Definition at line 1721 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<typename 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<typename GUM_SCALAR>

PRMClass< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveClass_ ( const std::string & 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 1212 of file PRMFactory_tpl.h.

                                                                             {
      PRMClass< GUM_SCALAR >* a_class = nullptr;
      std::string             full_name;
 
      // Looking for the type using its name
      if (_prm_->_classMap_.exists(name)) {
        a_class   = _prm_->_classMap_[name];
        full_name = name;
      }
 
      // Looking for the type using current package
      std::string prefixed = _addPrefix_(name);
      if (_prm_->_classMap_.exists(prefixed)) {
        if (a_class == nullptr) {
          a_class   = _prm_->_classMap_[prefixed];
          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 + "." + name;
          if (_prm_->_classMap_.exists(ns_name)) {
            if (a_class == 0) {
              a_class   = _prm_->_classMap_[ns_name];
              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<typename GUM_SCALAR>

INLINE 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 1031 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 (counters.exists(current->name())) {
              ++(counters[current->name()]);
            } 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
      current = 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;
            current   = _retrieveType_(elt.first);
          }
        }
      }
 
      if (current) { return const_cast< PRMType* >(current); }
 
      GUM_ERROR(NotFound, "could not find a common type")
    }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

_retrieveInputs_()

template<typename GUM_SCALAR>

INLINE 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 975 of file PRMFactory_tpl.h.

                                                             {
      bool retVal = false;
 
      for (size_t i = 0; i < chains.size(); ++i) {
        try {
          inputs.push_back(&(c->get(chains[i])));
          retVal = retVal || PRMClassElement< GUM_SCALAR >::isSlotChain(*(inputs.back()));
        } catch (NotFound const&) {
          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();
 
            try {
              toAdd.push_back(std::make_pair(elt, &(c->get(name.str()))));
            } catch (NotFound const&) {
              toAdd.push_back(std::make_pair(elt, _buildSlotChain_(c, name.str())));
            }
          } else {
            std::stringstream name;
            name << "(" << t->name() << ")" << elt->name();
            toAdd.push_back(std::make_pair(elt, &(c->get(name.str()))));
          }
        }
      }
 
      return retVal;
    }

References _buildSlotChain_(), _retrieveCommonType_(), gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMSlotChain< GUM_SCALAR >::chain(), 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<typename 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<typename GUM_SCALAR>

PRMInterface< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveInterface_ ( const std::string & 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 1259 of file PRMFactory_tpl.h.

                                                                                 {
      PRMInterface< GUM_SCALAR >* interface = nullptr;
      std::string                 full_name;
 
      // Looking for the type using its name
      if (_prm_->_interfaceMap_.exists(name)) {
        interface = _prm_->_interfaceMap_[name];
        full_name = name;
      }
 
      // Looking for the type using current package
      std::string prefixed = _addPrefix_(name);
      if (_prm_->_interfaceMap_.exists(prefixed)) {
        if (interface == nullptr) {
          interface = _prm_->_interfaceMap_[prefixed];
          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 + "." + name;
 
          if (_prm_->_interfaceMap_.exists(ns_name)) {
            if (interface == nullptr) {
              interface = _prm_->_interfaceMap_[ns_name];
              full_name = ns_name;
            } else if (full_name != ns_name) {
              GUM_ERROR(DuplicateElement,
                        "Interface name '" << name << "' is ambiguous: specify full name.");
            }
          }
        }
      }
 
      if (interface == nullptr) {
        GUM_ERROR(NotFound, "Interface '" << name << "' not found, check imports.")
      }
 
      return 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<typename GUM_SCALAR>

INLINE PRMType * gum::prm::PRMFactory< GUM_SCALAR >::_retrieveType_ ( const std::string & 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 1149 of file PRMFactory_tpl.h.

                                                                                        {
      PRMType*    type = nullptr;
      std::string full_name;
 
      // Looking for the type using its name
      if (_prm_->_typeMap_.exists(name)) {
        type      = _prm_->_typeMap_[name];
        full_name = name;
      }
 
      // Looking for the type in current package
      std::string prefixed = _addPrefix_(name);
      if (_prm_->_typeMap_.exists(prefixed)) {
        if (type == 0) {
          type      = _prm_->_typeMap_[prefixed];
          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();
      size_t      last_dot   = relatif_ns.find_last_of('.');
      if (last_dot != std::string::npos) {
        relatif_ns = relatif_ns.substr(0, last_dot) + '.' + name;
        if (_prm_->_typeMap_.exists(relatif_ns)) {
          if (type == 0) {
            type      = _prm_->_typeMap_[relatif_ns];
            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 + "." + name;
          if (_prm_->_typeMap_.exists(ns_name)) {
            if (type == 0) {
              type      = _prm_->_typeMap_[ns_name];
              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<typename GUM_SCALAR>

INLINE 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 1759 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addAggregator ( const std::string & name, const std::string & agg_type, const std::vector< std::string > & chains, const std::vector< std::string > & params, std::string 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 671 of file PRMFactory_tpl.h.

                                                                                              {
      PRMClass< GUM_SCALAR >* c
          = static_cast< PRMClass< GUM_SCALAR >* >(_checkStack_(1, PRMObject::prm_type::CLASS));
      // Checking call legality
 
      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)) {
        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,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type),
                                               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,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type),
                                               *(_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);
 
          // Creating and adding the PRMAggregate<GUM_SCALAR>
          agg = new PRMAggregate< GUM_SCALAR >(name,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type),
                                               *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);
 
          // Creating and adding the PRMAggregate<GUM_SCALAR>
          agg = new PRMAggregate< GUM_SCALAR >(name,
                                               PRMAggregate< GUM_SCALAR >::str2enum(agg_type),
                                               *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 {
            c->add(attr);
          } catch (DuplicateElement const&) { c->overload(attr); }
 
          delete agg;
        }
      } catch (DuplicateElement const&) {
        delete agg;
        throw;
      }
 
      for (const auto& elt: inputs) {
        c->addArc(elt->safeName(), safe_name);
      }
    }

References _checkStack_(), _retrieveInputs_(), _retrieveType_(), gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMAggregate< GUM_SCALAR >::AMPLITUDE, gum::prm::PRMAggregate< GUM_SCALAR >::AND, gum::prm::PRMAggregate< GUM_SCALAR >::buildImpl(), 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::PRMAggregate< GUM_SCALAR >::label(), gum::prm::PRMAggregate< GUM_SCALAR >::MAX, gum::prm::PRMAggregate< GUM_SCALAR >::MEDIAN, gum::prm::PRMAggregate< GUM_SCALAR >::MIN, gum::prm::PRMObject::name(), gum::prm::PRMAggregate< GUM_SCALAR >::OR, gum::prm::PRMClass< GUM_SCALAR >::overload(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAggregate< GUM_SCALAR >::str2enum(), gum::prm::PRMAggregate< GUM_SCALAR >::SUM, and gum::prm::PRMAggregate< GUM_SCALAR >::type().

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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addArray ( const std::string & type, const std::string & 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 {
        model->addArray(name, *c);
 
        for (Size i = 0; i < size; ++i) {
          std::stringstream elt_name;
          elt_name << name << "[" << i << "]";
          inst = new PRMInstance< GUM_SCALAR >(elt_name.str(), *c);
          model->add(name, inst);
        }
      } 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addAttribute ( const std::string & type, const std::string & name )

overridevirtual

Add an attribute to an interface.

Implements gum::prm::IPRMFactory.

Definition at line 1521 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:

addAttribute() [2/2]

template<typename GUM_SCALAR>

INLINE 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 228 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:

addImport()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addImport ( const std::string & 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 1796 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(name);
    }

References _namespaces_, and GUM_ERROR.

addInstance() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addInstance ( const std::string & type, const std::string & name )

overridevirtual

Add an instance to the model.

Implements gum::prm::IPRMFactory.

Definition at line 1599 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addInstance ( const std::string & type, const std::string & 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 1615 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addLabel ( const std::string & l, std::string 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 1391 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addNoisyOrCompound ( const std::string & 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 1086 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_SCALAR >::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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addParameter ( const std::string & type, const std::string & 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 539 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addParent ( const std::string & 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 306 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addRangeType ( const std::string & 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 1495 of file PRMFactory_tpl.h.

                                                                                              {
      std::string real_name = _addPrefix_(name);
      if (_prm_->_typeMap_.exists(real_name)) {
        std::stringstream msg;
        msg << "\"" << real_name << "' is already used.";
        GUM_ERROR(DuplicateElement, msg.str())
      }
 
      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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addReferenceSlot ( const std::string & type, const std::string & 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<typename GUM_SCALAR>

INLINE 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 1466 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<typename GUM_SCALAR>

INLINE 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 1357 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::continueAggregator

(

const std::string &

name

)

Conitnues an aggregator declaration.

Definition at line 595 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::continueAttribute ( const std::string & name )

overridevirtual

Continues the declaration of an attribute.

Implements gum::prm::IPRMFactory.

Definition at line 1558 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::continueClass ( const std::string & c )

overridevirtual

Continue the declaration of a class.

Implements gum::prm::IPRMFactory.

Definition at line 99 of file PRMFactory_tpl.h.

                                                                             {
      std::string real_name = _addPrefix_(name);
      if (!(_prm_->_classMap_.exists(real_name))) {
        std::stringstream msg;
        msg << "'" << real_name << "' not found";
        GUM_ERROR(NotFound, msg.str())
      }
      _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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::continueInterface ( const std::string & name )

overridevirtual

Continue the declaration of an interface.

Implements gum::prm::IPRMFactory.

Definition at line 217 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<typename GUM_SCALAR>

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

overridevirtual

Returns

Returns the current package name.

Implements gum::prm::IPRMFactory.

Definition at line 1368 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<typename GUM_SCALAR>

INLINE 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 1336 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::endAggregator

(

)

Finishes an aggregate declaration.

Definition at line 665 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<typename GUM_SCALAR>

INLINE 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 1572 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<typename GUM_SCALAR>

INLINE 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 110 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<typename GUM_SCALAR>

INLINE 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 1439 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<typename GUM_SCALAR>

INLINE 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 1480 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<typename GUM_SCALAR>

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

overridevirtual

Tells the factory that we finished an interface declaration.

Implements gum::prm::IPRMFactory.

Definition at line 1515 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<typename GUM_SCALAR>

INLINE 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 1589 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<typename GUM_SCALAR>

INLINE 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 1350 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<typename GUM_SCALAR>

INLINE 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 1343 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::incArray ( const std::string & l_i, const std::string & 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(l_i)) {
        if (model->isInstance(r_i)) {
          model->add(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<typename GUM_SCALAR>

INLINE bool gum::prm::PRMFactory< GUM_SCALAR >::isArrayInCurrentSystem ( const std::string & name ) const

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1852 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<typename GUM_SCALAR>

INLINE bool gum::prm::PRMFactory< GUM_SCALAR >::isClassOrInterface ( const std::string & type ) const

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1833 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<typename 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<typename GUM_SCALAR>

INLINE 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 1778 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<typename GUM_SCALAR>

INLINE 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 1331 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::pushPackage ( const std::string & 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 1772 of file PRMFactory_tpl.h.

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

References _namespaces_, and _packages_.

retrieveClass()

template<typename GUM_SCALAR>

INLINE PRMClass< GUM_SCALAR > & gum::prm::PRMFactory< GUM_SCALAR >::retrieveClass

(

const std::string &

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 1817 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<typename GUM_SCALAR>

INLINE 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 1827 of file PRMFactory_tpl.h.

                                                                 {
      return *(_retrieveCommonType_(elts));
    }

References _retrieveCommonType_().

Here is the call graph for this function:

retrieveType()

template<typename GUM_SCALAR>

INLINE PRMType & gum::prm::PRMFactory< GUM_SCALAR >::retrieveType

(

const std::string &

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 1822 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<typename GUM_SCALAR>

INLINE 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 393 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<typename GUM_SCALAR>

INLINE 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 411 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<typename GUM_SCALAR>

INLINE 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 475 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<typename GUM_SCALAR>

INLINE 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 361 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<typename GUM_SCALAR>

INLINE 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 1860 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<typename GUM_SCALAR>

INLINE 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 347 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<typename GUM_SCALAR>

INLINE 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
 0.50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
 0.70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
 0.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 321 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<typename GUM_SCALAR>

INLINE 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
 0.50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
 0.70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
 0.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 333 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<typename GUM_SCALAR>

INLINE 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
 0.50, 0.50, // P(f|t, f) = 0.50 and P(t|t, f) = 0.50
 0.70, 0.30, // P(f|f, t) = 0.70 and P(t|f, t) = 0.30
 0.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 1897 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_SCALAR >::populate(), and gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute.

Here is the call graph for this function:

setReferenceSlot() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot ( const std::string & l_i, const std::string & 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 1803 of file PRMFactory_tpl.h.

                                                                                 {
      size_t pos = l_i.find_last_of('.');
 
      if (pos != std::string::npos) {
        std::string l_ref = l_i.substr(pos + 1, std::string::npos);
        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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot ( const std::string & left_instance, const std::string & left_reference, const std::string & 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(l_i)) {
        lefts.push_back(&(model->get(l_i)));
      } else if (model->isArray(l_i)) {
        for (const auto& elt: model->getArray(l_i))
          lefts.push_back(elt);
      } else {
        GUM_ERROR(NotFound, "left value does not name an instance or an array")
      }
 
      if (model->isInstance(r_i)) {
        rights.push_back(&(model->get(r_i)));
      } else if (model->isArray(r_i)) {
        for (const auto& elt: model->getArray(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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startAggregator	(	const std::string &	name,
		const std::string &	agg_type,
		const std::string &	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 562 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startAttribute ( const std::string & type, const std::string & 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 1529 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startClass ( const std::string & c, const std::string & 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 63 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType ( const std::string & name, std::string 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 1373 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startDiscretizedType ( const std::string & 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 1455 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startInterface ( const std::string & i, const std::string & 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 193 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<typename GUM_SCALAR>

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startSystem ( const std::string & 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 1578 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<typename 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 1046 of file PRMFactory.h.

_namespaces_

template<typename GUM_SCALAR>

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

private

Set of all declared namespaces.

Definition at line 1037 of file PRMFactory.h.

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

_packages_

template<typename 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 1034 of file PRMFactory.h.

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

_prm_

template<typename 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 1040 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<typename GUM_SCALAR>

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

private

A stack used to keep track of created PRMObject.

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