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 47 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 1348 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 1354 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 1360 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__namespaces.

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

Member Function Documentation

__addInstance()

template<typename GUM_SCALAR >

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

private

Adds a instance to the current model.

Definition at line 1738 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMInstance< GUM_SCALAR >::add(), and gum::prm::PRMObject::SYSTEM.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

__addParent() [1/2]

template<typename GUM_SCALAR >

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

private

Add a parent to an attribute.

Definition at line 248 of file PRMFactory_tpl.h.

References gum::prm::PRMClassElementContainer< GUM_SCALAR >::add(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::addArc(), gum::prm::PRMClassElement< GUM_SCALAR >::elt_type(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMSlotChain< GUM_SCALAR >::isMultiple(), and gum::prm::PRMObject::name().

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

Here is the call graph for this function:

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

References gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMAggregate< GUM_SCALAR >::agg_type(), GUM_ERROR, gum::prm::PRMAggregate< GUM_SCALAR >::hasLabel(), gum::prm::PRMAggregate< GUM_SCALAR >::labelValue(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), and gum::prm::PRMAggregate< GUM_SCALAR >::setLabel().

                                                                             {
      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(WrongType, "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::MEDIAN:
        case PRMAggregate< GUM_SCALAR >::AggregateType::AMPLITUDE:
        case PRMAggregate< GUM_SCALAR >::AggregateType::MIN:
        case PRMAggregate< GUM_SCALAR >::AggregateType::MAX: {
          break;
        }

        default: { GUM_ERROR(FatalError, "Unknown aggregator."); }
      }

      c->addArc(inputs.front()->safeName(), agg->safeName());
    }

Here is the call graph for this function:

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

References gum::prm::PRMFactory< GUM_SCALAR >::__packages.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::addRangeType(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscretizedType(), and gum::prm::PRMFactory< GUM_SCALAR >::startSystem().

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

Here is the caller graph for this function:

__buildAggregateCPF()

template<typename GUM_SCALAR>

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

private

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

__buildSlotChain()

template<typename GUM_SCALAR >

INLINE PRMSlotChain< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::__buildSlotChain ( PRMClassElementContainer< GUM_SCALAR > *  start, const std::string &  name  )

private

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

Returns

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

Definition at line 949 of file PRMFactory_tpl.h.

References gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::back(), gum::prm::decomposePath(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::insert(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::setOutputNode(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::size(), and gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType().

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

Here is the call graph for this function:

__buildSlotChains()

template<typename GUM_SCALAR>

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

private

Builds all PRMSlotChain<GUM_SCALAR><PRMInstance<GUM_SCALAR>> in the given model.

Exceptions

OperationNotAllowed

If reference slots are left un affected

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

References gum::prm::PRMClass< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClass< GUM_SCALAR >::implements(), gum::prm::PRMObject::name(), and gum::prm::PRMReferenceSlot< GUM_SCALAR >::slotType().

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

Here is the call graph for this function:

__checkStack() [1/2]

template<typename GUM_SCALAR >

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

private

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

Exceptions

FactoryInvalidState

Raised if the stack isn't consistent with the

Definition at line 1768 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__stack, GUM_ERROR, and gum::prm::PRMObject::obj_type().

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::__addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::addLabel(), gum::prm::PRMFactory< GUM_SCALAR >::addTick(), gum::prm::PRMFactory< GUM_SCALAR >::endAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscretizedType(), gum::prm::PRMFactory< GUM_SCALAR >::endInterface(), gum::prm::PRMFactory< GUM_SCALAR >::endSystem(), gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns(), and gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines().

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

Here is the call graph for this function:

Here is the caller graph for this function:

__checkStack() [2/2]

template<typename GUM_SCALAR >

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

private

Adds __prefix to str iff __prefix != "".

Definition at line 1803 of file PRMFactory_tpl.h.

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

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

Here is the call graph for this function:

__checkStackContainter()

template<typename GUM_SCALAR >

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

private

Adds __prefix to str iff __prefix != "".

Definition at line 1786 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__stack, gum::prm::PRMObject::CLASS, GUM_ERROR, gum::prm::PRMObject::obj_type(), and gum::prm::PRMObject::PRM_INTERFACE.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

__fill_sc_in_vector()

template<typename GUM_SCALAR>

void gum::prm::PRMFactory< GUM_SCALAR >::__fill_sc_in_vector ( std::vector< std::string > &  v, const std::string &  str  )

private

Decompose a string in v using dots ('.') as delimiters.

__instantiateSlotChain()

template<typename GUM_SCALAR>

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

private

Instantiate a slot chain in the given instance.

__retrieveClass()

template<typename GUM_SCALAR >

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

private

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

Exceptions

NotFound

If no class matching the name is found.

See also

PRMFactory::__retrieveType

Definition at line 1244 of file PRMFactory_tpl.h.

References GUM_ERROR.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::isClassOrInterface(), and gum::prm::PRMFactory< GUM_SCALAR >::retrieveClass().

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

Here is the caller graph for this function:

__retrieveCommonType()

template<typename GUM_SCALAR >

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

private

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

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

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

Parameters

elts	A vector of PRMClassElement<GUM_SCALAR>.

Returns

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

Exceptions

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

Definition at line 1051 of file PRMFactory_tpl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

__retrieveInputs()

template<typename GUM_SCALAR >

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

private

Retrieve inputs for an PRMAggregate.

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

Parameters

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

Returns

true if there was at least one slotchain in chains.

Exceptions

NotFound

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

Definition at line 991 of file PRMFactory_tpl.h.

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

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

Here is the call graph for this function:

__retrieveInstanceSequence()

template<typename GUM_SCALAR>

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

private

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

Returns

Returns the name of the corresponding PRMSlotChain<GUM_SCALAR>.

__retrieveInterface()

template<typename GUM_SCALAR >

PRMInterface< GUM_SCALAR > * gum::prm::PRMFactory< GUM_SCALAR >::__retrieveInterface ( const std::string &  name ) const

private

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

Exceptions

NotFound

If no class matching the name is found.

See also

PRMFactory::__retrieveType

Definition at line 1294 of file PRMFactory_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

__retrieveType()

template<typename GUM_SCALAR >

INLINE PRMType * gum::prm::PRMFactory< GUM_SCALAR >::__retrieveType ( const std::string &  name ) const

private

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

The following precedences on finding the name is used:

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

  Exceptions

  OperationNotAllowed

  If the type is undeclared.

Definition at line 1176 of file PRMFactory_tpl.h.

References GUM_ERROR.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::retrieveType(), gum::prm::PRMFactory< GUM_SCALAR >::startAttribute(), and gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType().

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

Here is the caller graph for this function:

__typeDepth()

template<typename GUM_SCALAR >

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

private

Returns the inheritance depth of a PRMType.

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

Parameters

t	The PRMType for which we compute its depth.

Returns

Returns the depth of t.

Definition at line 1826 of file PRMFactory_tpl.h.

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

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

      return depth;
    }

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

References gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMAggregate< GUM_SCALAR >::buildImpl(), gum::prm::PRMObject::CLASS, GUM_ERROR, gum::prm::PRMAggregate< GUM_SCALAR >::label(), gum::prm::PRMObject::name(), gum::prm::PRMClass< GUM_SCALAR >::overload(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAggregate< GUM_SCALAR >::str2enum(), and gum::prm::PRMAggregate< GUM_SCALAR >::type().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster().

                                             {
      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(WrongType, "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(WrongType, "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::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);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

addArray()

template<typename GUM_SCALAR >

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

overridevirtual

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

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

Implements gum::prm::IPRMFactory.

Definition at line 866 of file PRMFactory_tpl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

addAttribute() [1/2]

template<typename GUM_SCALAR >

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

overridevirtual

Add an attribute to an interface.

Implements gum::prm::IPRMFactory.

Definition at line 1578 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::endAttribute(), gum::prm::PRMObject::PRM_INTERFACE, and gum::prm::PRMFactory< GUM_SCALAR >::startAttribute().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

addAttribute() [2/2]

template<typename GUM_SCALAR >

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

virtual

Add an already created attribute to the current class.

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

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

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

Parameters

attr	The attribute added to the current class.

Exceptions

NotFound

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

Definition at line 222 of file PRMFactory_tpl.h.

References gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMClass< GUM_SCALAR >::addArc(), gum::prm::PRMObject::CLASS, gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), GUM_ERROR, gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAttribute< GUM_SCALAR >::type(), and gum::prm::PRMType::variable().

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

Here is the call graph for this function:

addImport()

template<typename GUM_SCALAR >

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

overridevirtual

Add an import for namespace lookup.

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

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

Parameters

name	The name of the package for all further objects.

Implements gum::prm::IPRMFactory.

Definition at line 1863 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__namespaces, and GUM_ERROR.

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

References gum::prm::PRMFactory< GUM_SCALAR >::__addInstance(), and gum::prm::PRMFactory< GUM_SCALAR >::__retrieveClass().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

addInstance() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

Implements gum::prm::IPRMFactory.

Definition at line 1671 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::__packages, gum::prm::PRMFactory< GUM_SCALAR >::__retrieveClass(), gum::prm::PRMFactory< GUM_SCALAR >::addParameter(), gum::HashTable< Key, Val, Alloc >::empty(), gum::prm::PRMFactory< GUM_SCALAR >::endClass(), GUM_ERROR, gum::HashTable< Key, Val, Alloc >::insert(), and gum::prm::PRMFactory< GUM_SCALAR >::startClass().

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

Here is the call graph for this function:

addLabel()

template<typename GUM_SCALAR >

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addLabel ( const std::string &  l, std::string  ext = ""  )

overridevirtual

Add a label to the current discrete type.

Parameters

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

Exceptions

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

Implements gum::prm::IPRMFactory.

Definition at line 1431 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::LabelizedVariable::addLabel(), gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::DiscreteVariable::label(), and gum::prm::PRMObject::TYPE.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

addNoisyOrCompound()

template<typename GUM_SCALAR >

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

overridevirtual

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

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

Parameters

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

Exceptions

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

Implements gum::prm::IPRMFactory.

Definition at line 1106 of file PRMFactory_tpl.h.

References gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMClassElement< GUM_SCALAR >::cast(), gum::MultiDimICIModel< GUM_SCALAR >::causalWeight(), gum::prm::PRMObject::CLASS, gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), and GUM_ERROR.

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

Here is the call graph for this function:

addParameter()

template<typename GUM_SCALAR >

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

overridevirtual

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

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

Parameters

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

Implements gum::prm::IPRMFactory.

Definition at line 542 of file PRMFactory_tpl.h.

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

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

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

Here is the caller graph for this function:

addParent()

template<typename GUM_SCALAR >

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

overridevirtual

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

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

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 303 of file PRMFactory_tpl.h.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__completeAggregates(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__completeAttribute(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster().

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

Here is the caller graph for this function:

addRangeType()

template<typename GUM_SCALAR >

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::addRangeType ( const std::string &  name, long  minVal, long  maxVal  )

overridevirtual

Add a range variable type declaration.

Parameters

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

Exceptions

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

Implements gum::prm::IPRMFactory.

Definition at line 1549 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__addPrefix(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, and GUM_ERROR.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

addReferenceSlot()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we started declaring a slot.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 841 of file PRMFactory_tpl.h.

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

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__addReferenceSlots(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateInterfaces(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateInterfaces(), and gum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR >::buildElements().

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

Here is the call graph for this function:

Here is the caller graph for this function:

addTick()

template<typename GUM_SCALAR >

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

overridevirtual

Add a tick to the current discretized type.

Parameters

tick	The tick value.

Implements gum::prm::IPRMFactory.

Definition at line 1514 of file PRMFactory_tpl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

closeCurrent()

template<typename GUM_SCALAR >

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

overridevirtual

Close current object being built.

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

Returns

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

Implements gum::prm::IPRMFactory.

Definition at line 1396 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__stack.

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

continueAttribute()

template<typename GUM_SCALAR >

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

overridevirtual

Continues the declaration of an attribute.

Implements gum::prm::IPRMFactory.

Definition at line 1617 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStackContainter(), gum::prm::PRMFactory< GUM_SCALAR >::__stack, gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::get(), and GUM_ERROR.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

continueClass()

template<typename GUM_SCALAR >

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

overridevirtual

Continue the declaration of a class.

Implements gum::prm::IPRMFactory.

Definition at line 82 of file PRMFactory_tpl.h.

References GUM_ERROR.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__addReferenceSlots(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAggregates(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAttribute(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildParameters(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttributes().

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

Here is the caller graph for this function:

continueInterface()

template<typename GUM_SCALAR >

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

overridevirtual

Continue the declaration of an interface.

Implements gum::prm::IPRMFactory.

Definition at line 210 of file PRMFactory_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

currentPackage()

template<typename GUM_SCALAR >

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

overridevirtual

Returns

Returns the current package name.

Implements gum::prm::IPRMFactory.

Definition at line 1407 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__packages.

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

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

Here is the caller graph for this function:

currentType()

template<typename GUM_SCALAR >

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

overridevirtual

Returns

Returns the PRMObject type of the object begin built.

Exceptions

NotFound

if no type is being built.

Implements gum::prm::IPRMFactory.

Definition at line 1375 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__stack, and GUM_ERROR.

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

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__completeAggregates(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAggregates().

                                                        {
      __checkStack(1, PRMClassElement< GUM_SCALAR >::prm_aggregate);
      __stack.pop_back();
    }

Here is the caller graph for this function:

endAttribute()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we finished declaring an attribute.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1628 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), and gum::prm::PRMFactory< GUM_SCALAR >::__stack.

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__completeAttribute(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAttribute(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), and gum::prm::PRMFactory< GUM_SCALAR >::addAttribute().

                                                       {
      __checkStack(1, PRMClassElement< GUM_SCALAR >::prm_attribute);
      __stack.pop_back();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

endClass()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we finished a class declaration.

Exceptions

TypeError

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

Implements gum::prm::IPRMFactory.

Definition at line 93 of file PRMFactory_tpl.h.

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

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__addReferenceSlots(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAggregates(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAttribute(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildClasses(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildParameters(), gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttributes().

                                                                            {
      PRMClass< GUM_SCALAR >* c = static_cast< PRMClass< GUM_SCALAR >* >(
         __checkStack(1, PRMObject::prm_type::CLASS));

      if (checkImplementations) { __checkInterfaceImplementation(c); }

      __stack.pop_back();
    }

Here is the caller graph for this function:

endDiscreteType()

template<typename GUM_SCALAR >

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

overridevirtual

End the current discrete type declaration.

Exceptions

OperationNotAllowed

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

Implements gum::prm::IPRMFactory.

Definition at line 1484 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, gum::prm::PRMFactory< GUM_SCALAR >::__stack, gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Variable::name(), and gum::prm::PRMObject::TYPE.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

endDiscretizedType()

template<typename GUM_SCALAR >

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

overridevirtual

End the current discretized type declaration.

Exceptions

OperationNotAllowed

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

Implements gum::prm::IPRMFactory.

Definition at line 1533 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, gum::prm::PRMFactory< GUM_SCALAR >::__stack, gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::Variable::name(), and gum::prm::PRMObject::TYPE.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

endInterface()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we finished an interface declaration.

Implements gum::prm::IPRMFactory.

Definition at line 1572 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::__stack, and gum::prm::PRMObject::PRM_INTERFACE.

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

                                                       {
      __checkStack(1, PRMObject::prm_type::PRM_INTERFACE);
      __stack.pop_back();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

endSystem()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we finished declaring a model.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1646 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::__stack, GUM_ERROR, gum::prm::PRMSystem< GUM_SCALAR >::instantiate(), and gum::prm::PRMObject::SYSTEM.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

References gum::prm::PRMFactory< GUM_SCALAR >::__stack, and GUM_ERROR.

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

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

      return __stack.back();
    }

Here is the caller graph for this function:

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

References gum::prm::PRMFactory< GUM_SCALAR >::__stack, and GUM_ERROR.

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

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

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

Here is the call graph for this function:

isArrayInCurrentSystem()

template<typename GUM_SCALAR >

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

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1927 of file PRMFactory_tpl.h.

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

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

Here is the call graph for this function:

isClassOrInterface()

template<typename GUM_SCALAR >

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

overridevirtual

Implements gum::prm::IPRMFactory.

Definition at line 1907 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__retrieveClass(), and gum::prm::PRMFactory< GUM_SCALAR >::__retrieveInterface().

                                    {
      try {
        __retrieveClass(type);
        return true;

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

      try {
        __retrieveInterface(type);
        return true;

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

      return false;
    }

Here is the call graph for this function:

operator=()

template<typename GUM_SCALAR>

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

delete

Copy operator. Don't use it.

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

References gum::prm::PRMFactory< GUM_SCALAR >::__namespaces, gum::prm::PRMFactory< GUM_SCALAR >::__packages, and gum::prm::PRMFactory< GUM_SCALAR >::currentPackage().

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

Here is the call graph for this function:

prm()

template<typename GUM_SCALAR >

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

(

)

const

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

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

Returns

Returns the PRM<GUM_SCALAR> created by this factory.

Definition at line 1370 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__prm.

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

                                                                  {
      return __prm;
    }

Here is the caller graph for this function:

pushPackage()

template<typename GUM_SCALAR >

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

overridevirtual

Define the current package.

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

Parameters

name	The name of the package for all further objects.

Implements gum::prm::IPRMFactory.

Definition at line 1839 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__namespaces, and gum::prm::PRMFactory< GUM_SCALAR >::__packages.

                                                                           {
      __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 1889 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__retrieveClass().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster().

                                                                        {
      return *__retrieveClass(name);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

retrieveCommonType()

template<typename GUM_SCALAR >

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

(

const std::vector< PRMClassElement< GUM_SCALAR > * > &

elts

)

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

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

Returns

Returns the PRM<GUM_SCALAR> created by this factory.

Definition at line 1900 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__retrieveCommonType().

                                                                {
      return *(__retrieveCommonType(elts));
    }

Here is the call graph for this function:

retrieveType()

template<typename GUM_SCALAR >

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

(

const std::string &

name

)

Returns a reference over a PRMType given its name.

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

Parameters

name	The name of the PRMType.

Returns

the PRMType with the given name.

Exceptions

NotFound

if no PRMType matches the given name.

Definition at line 1895 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__retrieveType().

                                                                       {
      return *__retrieveType(name);
    }

Here is the call graph for this function:

setCPFByFloatRule()

template<typename GUM_SCALAR >

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

overridevirtual

Fills the CPF using a rule.

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

Parameters

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

Implements gum::prm::IPRMFactory.

Definition at line 393 of file PRMFactory_tpl.h.

References GUM_ERROR.

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

References gum::Instantiation::chgVal(), gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::DiscreteVariable::label(), gum::Instantiation::setVals(), and gum::to_string().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

setCPFByRule() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

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

Parameters

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

Implements gum::prm::IPRMFactory.

Definition at line 477 of file PRMFactory_tpl.h.

References gum::Instantiation::chgVal(), gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::DiscreteVariable::label(), and gum::Instantiation::setVals().

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

Here is the call graph for this function:

setRawCPFByColumns() [1/2]

template<typename GUM_SCALAR >

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

(

const std::vector< GUM_SCALAR > &

array

)

Gives the factory the CPF in its raw form.

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

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

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

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Definition at line 360 of file PRMFactory_tpl.h.

References gum::Instantiation::add(), gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), and GUM_ERROR.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

setRawCPFByColumns() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

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

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

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

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1935 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::Instantiation::add(), gum::prm::PRMObject::CLASS, GUM_ERROR, and gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines().

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

Here is the call graph for this function:

setRawCPFByFloatColumns()

template<typename GUM_SCALAR >

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

overridevirtual

Gives the factory the CPF in its raw form.

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

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

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

See PRMFactory::setRawCPFByLines() for more details.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 346 of file PRMFactory_tpl.h.

References gum::prm::PRMAttribute< GUM_SCALAR >::cpf(), and GUM_ERROR.

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

Here is the call graph for this function:

setRawCPFByFloatLines()

template<typename GUM_SCALAR >

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

overridevirtual

Gives the factory the CPF in its raw form.

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

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

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

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 318 of file PRMFactory_tpl.h.

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

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

Here is the call graph for this function:

setRawCPFByLines() [1/2]

template<typename GUM_SCALAR >

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

(

const std::vector< GUM_SCALAR > &

array

)

Gives the factory the CPF in its raw form.

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

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

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

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Definition at line 332 of file PRMFactory_tpl.h.

References gum::prm::PRMObject::CLASS, and GUM_ERROR.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), and gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns().

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

Here is the caller graph for this function:

setRawCPFByLines() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

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

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

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

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1973 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMObject::CLASS, and GUM_ERROR.

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

Here is the call graph for this function:

setReferenceSlot() [1/2]

template<typename GUM_SCALAR >

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

References GUM_ERROR, and gum::prm::PRMObject::SYSTEM.

Referenced by gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::__addAssignments(), gum::prm::o3prm::O3SystemFactory< GUM_SCALAR >::__addIncrements(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateSystem(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateSystem(), and gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot().

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

Here is the caller graph for this function:

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

References GUM_ERROR, and gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot().

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

Here is the call graph for this function:

startAggregator()

template<typename GUM_SCALAR >

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

Start an aggregator declaration.

Parameters

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

See also

Aggregate::agg_type()).

Parameters

rv_type

The aggregator's random variable type (

See also

Aggregate::type()).

Parameters

params

The aggregator's parameters.

Definition at line 567 of file PRMFactory_tpl.h.

References gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMObject::CLASS, GUM_ERROR, gum::prm::PRMClass< GUM_SCALAR >::overload(), and gum::prm::PRMAggregate< GUM_SCALAR >::str2enum().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

startAttribute()

template<typename GUM_SCALAR >

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startAttribute ( const std::string &  type, const std::string &  name, bool  scalar_atttr = false  )

overridevirtual

Tells the factory that we start an attribute declaration.

Exceptions

FatalError

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1586 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__checkStackContainter(), gum::prm::PRMFactory< GUM_SCALAR >::__retrieveType(), gum::prm::PRMFactory< GUM_SCALAR >::__stack, gum::prm::PRMClassElementContainer< GUM_SCALAR >::add(), gum::prm::PRMClassElementContainer< GUM_SCALAR >::exists(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::prm::PRMObject::isClass(), and gum::prm::PRMClassElementContainer< GUM_SCALAR >::overload().

Referenced by gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::__declareAttribute(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), and gum::prm::PRMFactory< GUM_SCALAR >::addAttribute().

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

Here is the call graph for this function:

Here is the caller graph for this function:

startClass()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we start a class declaration.

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

Parameters

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

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 45 of file PRMFactory_tpl.h.

References gum::Set< Key, Alloc >::empty(), GUM_ERROR, gum::Set< Key, Alloc >::insert(), and gum::prm::PRMObject::name().

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateClass(), gum::prm::LayerGenerator< GUM_SCALAR >::__generateClasses(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateCluster(), gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildClasses().

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

Here is the call graph for this function:

Here is the caller graph for this function:

startDiscreteType()

template<typename GUM_SCALAR >

INLINE void gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType ( const std::string &  name, std::string  super = ""  )

overridevirtual

Start a discrete subtype declaration.

Parameters

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

Exceptions

DuplicateElement

Raised if an object with the same name already exists.

Implements gum::prm::IPRMFactory.

Definition at line 1413 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__addPrefix(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, gum::prm::PRMFactory< GUM_SCALAR >::__retrieveType(), gum::prm::PRMFactory< GUM_SCALAR >::__stack, and GUM_ERROR.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

startDiscretizedType()

template<typename GUM_SCALAR >

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

overridevirtual

Start a discretized type declaration.

Parameters

name	The discretized type's name.

Exceptions

DuplicateElement

Raised if an object with the same name already exists.

Implements gum::prm::IPRMFactory.

Definition at line 1503 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__addPrefix(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, gum::prm::PRMFactory< GUM_SCALAR >::__stack, and GUM_ERROR.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

startInterface()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we start an interface declaration.

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

Parameters

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

Exceptions

NotFound

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

Implements gum::prm::IPRMFactory.

Definition at line 184 of file PRMFactory_tpl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

startSystem()

template<typename GUM_SCALAR >

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

overridevirtual

Tells the factory that we started declaring a model.

Exceptions

OperationNotAllowed

Raised if the given operation is illegal.

Implements gum::prm::IPRMFactory.

Definition at line 1634 of file PRMFactory_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::__addPrefix(), gum::prm::PRMFactory< GUM_SCALAR >::__prm, gum::prm::PRMFactory< GUM_SCALAR >::__stack, GUM_ERROR, and gum::prm::PRMObject::name().

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

__agg_params

template<typename GUM_SCALAR>

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

private

A mapping between aggregators and their parameters.

Definition at line 1053 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 1043 of file PRMFactory.h.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::addImport(), gum::prm::PRMFactory< GUM_SCALAR >::popPackage(), gum::prm::PRMFactory< GUM_SCALAR >::pushPackage(), and gum::prm::PRMFactory< GUM_SCALAR >::~PRMFactory().

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

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::__addPrefix(), gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::currentPackage(), gum::prm::PRMFactory< GUM_SCALAR >::popPackage(), and gum::prm::PRMFactory< GUM_SCALAR >::pushPackage().

__prm

template<typename GUM_SCALAR>

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

private

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

Definition at line 1046 of file PRMFactory.h.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::addRangeType(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscretizedType(), gum::prm::PRMFactory< GUM_SCALAR >::prm(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscretizedType(), and gum::prm::PRMFactory< GUM_SCALAR >::startSystem().

__stack

template<typename GUM_SCALAR>

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

private

A stack used to keep track of created PRMObject.

Definition at line 1049 of file PRMFactory.h.

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::__checkStack(), gum::prm::PRMFactory< GUM_SCALAR >::__checkStackContainter(), gum::prm::PRMFactory< GUM_SCALAR >::closeCurrent(), gum::prm::PRMFactory< GUM_SCALAR >::continueAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::currentType(), gum::prm::PRMFactory< GUM_SCALAR >::endAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscretizedType(), gum::prm::PRMFactory< GUM_SCALAR >::endInterface(), gum::prm::PRMFactory< GUM_SCALAR >::endSystem(), gum::prm::PRMFactory< GUM_SCALAR >::getCurrent(), gum::prm::PRMFactory< GUM_SCALAR >::startAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType(), gum::prm::PRMFactory< GUM_SCALAR >::startDiscretizedType(), and gum::prm::PRMFactory< GUM_SCALAR >::startSystem().

---

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

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