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

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

#include <PRMType.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. More...
	PRMFactory (PRM< GUM_SCALAR > *prm)
	This constructor let you set on which PRM instance the factory works. More...
	PRMFactory (const PRMFactory &from)=delete
	Copy constructor. Don't use it. More...
PRMFactory &	operator= (const PRMFactory &from)=delete
	Copy operator. Don't use it. More...
virtual	~PRMFactory ()
	Destructor. More...
Getters & Setters
PRM< GUM_SCALAR > *	prm () const
	Returns a pointer on the PRM<GUM_SCALAR> created by this factory. More...
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. More...
virtual PRMObject *	closeCurrent () override
	Close current object being built. More...
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. More...
PRMType &	retrieveType (const std::string &name)
	Returns a reference over a PRMType given its name. More...
PRMType &	retrieveCommonType (const std::vector< PRMClassElement< GUM_SCALAR > * > &elts)
	Returns a pointer on the PRM<GUM_SCALAR> created by this factory. More...
Package construction methods.
virtual void	pushPackage (const std::string &name) override
	Define the current package. More...
virtual std::string	popPackage () override
	Pop the current package from the package stack. More...
virtual void	addImport (const std::string &name) override
	Add an import for namespace lookup. More...
PRMType construction methods.
virtual void	startDiscreteType (const std::string &name, std::string super="") override
	Start a discrete subtype declaration. More...
virtual void	addLabel (const std::string &l, std::string ext="") override
	Add a label to the current discrete type. More...
virtual void	endDiscreteType () override
	End the current discrete type declaration. More...
virtual void	startDiscretizedType (const std::string &name) override
	Start a discretized type declaration. More...
virtual void	addTick (double tick) override
	Add a tick to the current discretized type. More...
virtual void	endDiscretizedType () override
	End the current discretized type declaration. More...
virtual void	addRangeType (const std::string &name, long minVal, long maxVal) override
	Add a range variable type declaration. More...
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. More...
virtual void	continueClass (const std::string &c) override
	Continue the declaration of a class. More...
virtual void	endClass (bool checkImplementations=true) override
	Tells the factory that we finished a class declaration. More...
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. More...
virtual void	continueInterface (const std::string &name) override
	Continue the declaration of an interface. More...
virtual void	addAttribute (const std::string &type, const std::string &name) override
	Add an attribute to an interface. More...
virtual void	endInterface () override
	Tells the factory that we finished an interface declaration. More...
Attributes construction methods.
virtual void	addAttribute (PRMAttribute< GUM_SCALAR > *attr)
	Add an already created attribute to the current class. More...
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. More...
virtual void	continueAttribute (const std::string &name) override
	Continues the declaration of an attribute. More...
virtual void	addParent (const std::string &name) override
	Tells the factory that we add a parent to the current declared attribute. More...
void	setRawCPFByLines (const std::vector< GUM_SCALAR > &array)
	Gives the factory the CPF in its raw form. More...
void	setRawCPFByColumns (const std::vector< GUM_SCALAR > &array)
	Gives the factory the CPF in its raw form. More...
virtual void	setCPFByRule (const std::vector< std::string > &labels, const std::vector< GUM_SCALAR > &values)
	Fills the CPF using a rule. More...
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. More...
virtual void	setRawCPFByFloatLines (const std::vector< float > &array) override
	Gives the factory the CPF in its raw form. More...
virtual void	setRawCPFByFloatColumns (const std::vector< float > &array) override
	Gives the factory the CPF in its raw form. More...
virtual void	setRawCPFByColumns (const std::vector< std::string > &array) override
	Gives the factory the CPF in its raw form use gum::Formula. More...
virtual void	setRawCPFByLines (const std::vector< std::string > &array) override
	Gives the factory the CPF in its raw form using gum::Formula. More...
virtual void	setCPFByFloatRule (const std::vector< std::string > &labels, const std::vector< float > &values) override
	Fills the CPF using a rule. More...
virtual void	endAttribute () override
	Tells the factory that we finished declaring an attribute. More...
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. More...
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. More...
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. More...
void	continueAggregator (const std::string &name)
	Conitnues an aggregator declaration. More...
void	endAggregator ()
	Finishes an aggregate declaration. More...
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>. More...
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. More...
Systems constructions methods.
virtual void	startSystem (const std::string &name) override
	Tells the factory that we started declaring a model. More...
virtual void	endSystem () override
	Tells the factory that we finished declaring a model. More...
virtual void	addInstance (const std::string &type, const std::string &name) override
	Add an instance to the model. More...
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. More...
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. More...
virtual void	incArray (const std::string &l_i, const std::string &r_i) override
	Add an instance to an array. More...
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. More...
virtual void	setReferenceSlot (const std::string &l_i, const std::string &r_i) override
	Instantiate a reference in the current model. More...

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 49 of file PRMType.h.

Constructor & Destructor Documentation

PRMFactory() [1/3]

template<typename GUM_SCALAR >

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

(

)

Default constructor.

Definition at line 1368 of file PRMFactory_tpl.h.

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

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

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

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.

~PRMFactory()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 1380 of file PRMFactory_tpl.h.

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

Member Function Documentation

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 682 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&) { 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&) { c->overload(attr); }

          delete agg;
        }
      } catch (DuplicateElement&) {
        delete agg;
        throw;
      }

      for (const auto& elt: inputs) {
        c->addArc(elt->safeName(), safe_name);
      }
    }

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 879 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&) {
        delete inst;
        throw;
      } catch (NotFound&) {
        delete inst;
        throw;
      }
    }

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

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

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 224 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&) {}
      }

      if (count != attr->cpf().variablesSequence().size()) {
        GUM_ERROR(NotFound, "unable to found all parents of this attribute");
      }
    }

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 1884 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);
    }

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 1676 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);
      }
    }

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 1691 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&) {
          // Sub Class already exists in this system
        }
        c = retrieveClass__(sub_c);
        addInstance__(c, name);
      }
    }

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 1758 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&) {
        if (i) { delete i; }
        throw;
      }
    }

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

                                                                             {
      if (extends == "") {
        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&) {
          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&) {
              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."); }
      }
    }

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

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 546 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&) { c->overload(p); }
    }

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 307 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&) {
        auto agg = static_cast< PRMAggregate< GUM_SCALAR >* >(
           checkStack__(1, PRMClassElement< GUM_SCALAR >::prm_aggregate));
        addParent__(static_cast< PRMClass< GUM_SCALAR >* >(c), agg, name);
      }
    }

addParent__() [1/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 250 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&) {
        // 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>.");
        }
      }
    }

addParent__() [2/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 619 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());
    }

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 1775 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;
      }
    }

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 1569 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);
    }

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

                                                                         {
      PRMClassElementContainer< GUM_SCALAR >* owner    = checkStackContainter__(1);
      PRMClassElementContainer< GUM_SCALAR >* slotType = 0;

      try {
        slotType = retrieveClass__(type);
      } catch (NotFound&) {
        try {
          slotType = retrieveInterface__(type);
        } catch (NotFound&) {
          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&) { owner->overload(ref); }
    }

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 1534 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&) {
        GUM_ERROR(OperationNotAllowed, "tick already in used for this variable");
      }
    }

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

      GUM_ASSERT(v.size() == elts.size());

      current->setOutputNode(*(elts.back()), true);

      return new PRMSlotChain< GUM_SCALAR >(name, elts);
    }

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 105 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&) {
            std::stringstream msg;
            msg << "class " << c->name() << " does not respect interface ";
            GUM_ERROR(PRMTypeError, msg.str() + i->name());
          }
        }
      } catch (NotFound&) {
        // this Class<GUM_SCALAR> does not implement any
        // PRMInterface<GUM_SCALAR>
      }
    }

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 1788 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;
    }

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 1823 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;
    }

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

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

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

continueAggregator()

template<typename GUM_SCALAR >

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

(

const std::string &

name

)

Conitnues an aggregator declaration.

Definition at line 607 of file PRMFactory_tpl.h.

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

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

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

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 84 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)));
    }

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 212 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);
    }

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

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

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

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

      return stack__.back()->obj_type();
    }

endAggregator()

template<typename GUM_SCALAR >

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

(

)

Finishes an aggregate declaration.

Definition at line 676 of file PRMFactory_tpl.h.

                                                        {
      checkStack__(1, PRMClassElement< GUM_SCALAR >::prm_aggregate);
      stack__.pop_back();
    }

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

                                                       {
      checkStack__(1, PRMClassElement< GUM_SCALAR >::prm_attribute);
      stack__.pop_back();
    }

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

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

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

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

                                                       {
      checkStack__(1, PRMObject::prm_type::PRM_INTERFACE);
      stack__.pop_back();
    }

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 1666 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&) { GUM_ERROR(FatalError, "could not create system"); }
    }

getCurrent() [1/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 1402 of file PRMFactory_tpl.h.

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

      return stack__.back();
    }

getCurrent() [2/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 1409 of file PRMFactory_tpl.h.

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

      return stack__.back();
    }

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

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.

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

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

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

                                    {
      try {
        retrieveClass__(type);
        return true;

      } catch (NotFound&) {
      } catch (DuplicateElement&) {}

      try {
        retrieveInterface__(type);
        return true;

      } catch (NotFound&) {
      } catch (DuplicateElement&) {}

      return false;
    }

operator=()

template<typename GUM_SCALAR >

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

delete

Copy operator. Don't use it.

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 1866 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;
    }

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

                                                                  {
      return prm__;
    }

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

                                                                           {
      packages__.push_back(name);
      namespaces__.push_back(new List< std::string >());
    }

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

                                                                        {
      return *retrieveClass__(name);
    }

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 1264 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;
    }

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

                                                                {
      return *(retrieveCommonType__(elts));
    }

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

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

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 1314 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;
    }

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

                                                                       {
      return *retrieveType__(name);
    }

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 1196 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;
    }

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 397 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);
    }

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

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

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 364 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;
        }
      }
    }

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

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 350 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);
    }

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 322 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);
    }

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 336 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);
    }

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

setReferenceSlot() [1/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 924 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");
          }
        }
      }
    }

setReferenceSlot() [2/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 1896 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");
      }
    }

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

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 1606 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&) { c->overload(a); }
      } catch (Exception&) {
        if (a != nullptr && (!c->exists(a->id()))) { delete a; }
      }

      stack__.push_back(a);
    }

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 47 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 == "") && 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 == "") && (!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);
    }

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

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 1523 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);
    }

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 186 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);
    }

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 1654 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);
    }

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

                                                                     {
      int            depth   = 0;
      const PRMType* current = t;

      while (current->isSubType()) {
        ++depth;
        current = &(current->superType());
      }

      return depth;
    }

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 1055 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 1045 of file PRMFactory.h.

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 1042 of file PRMFactory.h.

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 1048 of file PRMFactory.h.

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 1051 of file PRMFactory.h.

---

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