gum::prm::o3prm::O3ClassFactory< GUM_SCALAR > Class Template Reference

Builds gum::prm::Class from gum::prm::o3prm::O3Class. More...

#include <agrum/PRM/o3prm/O3ClassFactory.h>

Collaboration diagram for gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >:

Public Member Functions
	O3ClassFactory (PRM< GUM_SCALAR > &prm, O3PRM &o3_prm, O3NameSolver< GUM_SCALAR > &solver, ErrorsContainer &errors)
	O3ClassFactory (const O3ClassFactory< GUM_SCALAR > &src)
	O3ClassFactory (O3ClassFactory< GUM_SCALAR > &&src)
	~O3ClassFactory ()
O3ClassFactory< GUM_SCALAR > &	operator= (const O3ClassFactory< GUM_SCALAR > &src)
O3ClassFactory< GUM_SCALAR > &	operator= (O3ClassFactory< GUM_SCALAR > &&src)
void	buildClasses ()
void	buildImplementations ()
void	buildParameters ()
void	buildReferenceSlots ()
void	declareAggregates ()
void	completeAggregates ()
void	declareAttributes ()
void	completeAttributes ()

Detailed Description

template<typename GUM_SCALAR>
class gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >

Builds gum::prm::Class from gum::prm::o3prm::O3Class.

Template Parameters

GUM_SCALAR

The scalar type used by the gum::prm:PRM.

Definition at line 58 of file O3ClassFactory.h.

Constructor & Destructor Documentation

O3ClassFactory() [1/3]

template<typename GUM_SCALAR >

INLINE gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::O3ClassFactory	(	PRM< GUM_SCALAR > &	prm,
		O3PRM &	o3_prm,
		O3NameSolver< GUM_SCALAR > &	solver,
		ErrorsContainer &	errors
	)

Definition at line 37 of file O3ClassFactory_tpl.h.

                                             :
          prm__(&prm),
          o3_prm__(&o3_prm), solver__(&solver), errors__(&errors) {
        GUM_CONSTRUCTOR(O3ClassFactory);
      }

O3ClassFactory() [2/3]

template<typename GUM_SCALAR >

INLINE gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::O3ClassFactory

(

const O3ClassFactory< GUM_SCALAR > &

src

)

Definition at line 48 of file O3ClassFactory_tpl.h.

                                                  :
          prm__(src.prm__),
          o3_prm__(src.o3_prm__), solver__(src.solver__), errors__(src.errors__),
          nameMap__(src.nameMap__), classMap__(src.classMap__),
          nodeMap__(src.nodeMap__), dag__(src.dag__),
          o3Classes__(src.o3Classes__) {
        GUM_CONS_CPY(O3ClassFactory);
      }

O3ClassFactory() [3/3]

template<typename GUM_SCALAR >

INLINE gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::O3ClassFactory

(

O3ClassFactory< GUM_SCALAR > &&

src

)

Definition at line 59 of file O3ClassFactory_tpl.h.

                                             :
          prm__(std::move(src.prm__)),
          o3_prm__(std::move(src.o3_prm__)), solver__(std::move(src.solver__)),
          errors__(std::move(src.errors__)), nameMap__(std::move(src.nameMap__)),
          classMap__(std::move(src.classMap__)),
          nodeMap__(std::move(src.nodeMap__)), dag__(std::move(src.dag__)),
          o3Classes__(std::move(src.o3Classes__)) {
        GUM_CONS_MOV(O3ClassFactory);
      }

~O3ClassFactory()

template<typename GUM_SCALAR >

INLINE gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::~O3ClassFactory

(

)

Definition at line 71 of file O3ClassFactory_tpl.h.

                                                           {
        GUM_DESTRUCTOR(O3ClassFactory);
      }

Member Function Documentation

addParameters__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::addParameters__ ( PRMFactory< GUM_SCALAR > &  factory, O3Class &  c  )

private

Definition at line 331 of file O3ClassFactory_tpl.h.

                                      {
        for (auto& p: c.parameters()) {
          switch (p.type()) {
            case O3Parameter::PRMType::INT: {
              factory.addParameter("int", p.name().label(), p.value().value());
              break;
            }

            case O3Parameter::PRMType::FLOAT: {
              factory.addParameter("real", p.name().label(), p.value().value());
              break;
            }

            default: {
              GUM_ERROR(FatalError, "unknown O3Parameter type");
            }
          }
        }
      }

addParamsToForms__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::addParamsToForms__ ( const HashTable< std::string, const PRMParameter< GUM_SCALAR > * > &  scope, O3RuleCPT::O3Rule &  rule  )

private

Definition at line 734 of file O3ClassFactory_tpl.h.

                                                                                {
        // Add parameters to formulas
        for (auto& f: rule.second) {
          f.formula().variables().clear();
          for (const auto& values: scope) {
            f.formula().variables().insert(values.first, values.second->value());
          }
        }
      }

addReferenceSlots__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::addReferenceSlots__ ( O3Class &  c )

private

Definition at line 363 of file O3ClassFactory_tpl.h.

                                                                              {
        PRMFactory< GUM_SCALAR > factory(prm__);

        factory.continueClass(c.name().label());

        // References
        for (auto& ref: c.referenceSlots()) {
          if (checkReferenceSlot__(c, ref)) {
            factory.addReferenceSlot(ref.type().label(),
                                     ref.name().label(),
                                     ref.isArray());
          }
        }

        factory.endClass(false);
      }

buildClasses()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildClasses

(

)

Definition at line 108 of file O3ClassFactory_tpl.h.

                                                             {
        PRMFactory< GUM_SCALAR > factory(prm__);

        // Class with a super class must be declared after
        if (checkO3Classes__()) {
          setO3ClassCreationOrder__();

          for (auto c: o3Classes__) {
            // Soving interfaces
            auto implements = Set< std::string >();
            for (auto& i: c->interfaces()) {
              if (solver__->resolveInterface(i)) { implements.insert(i.label()); }
            }

            // Adding the class
            if (solver__->resolveClass(c->superLabel())) {
              factory.startClass(c->name().label(),
                                 c->superLabel().label(),
                                 &implements,
                                 true);
              factory.endClass(false);
            }
          }
        }
      }

buildImplementations()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildImplementations

(

)

Definition at line 190 of file O3ClassFactory_tpl.h.

                                                                     {
        for (auto& c: o3_prm__->classes()) {
          if (checkImplementation__(*c)) {
            prm__->getClass(c->name().label()).initializeInheritance();
          }
        }
      }

buildParameters()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildParameters

(

)

Definition at line 316 of file O3ClassFactory_tpl.h.

                                                                {
        PRMFactory< GUM_SCALAR > factory(prm__);
        // Class with a super class must be declared after
        for (auto c: o3Classes__) {
          prm__->getClass(c->name().label()).inheritParameters();

          factory.continueClass(c->name().label());

          addParameters__(factory, *c);

          factory.endClass(false);
        }
      }

buildReferenceSlots()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::buildReferenceSlots

(

)

Definition at line 354 of file O3ClassFactory_tpl.h.

                                                                    {
        // Class with a super class must be declared after
        for (auto c: o3Classes__) {
          prm__->getClass(c->name().label()).inheritReferenceSlots();
          addReferenceSlots__(*c);
        }
      }

checkAggParameters__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAggParameters__ ( O3Class &  o3class, O3Aggregate &  agg, const PRMType *  t  )

private

Definition at line 1031 of file O3ClassFactory_tpl.h.

                                                                              {
        bool ok = false;

        switch (gum::prm::PRMAggregate< GUM_SCALAR >::str2enum(
           agg.aggregateType().label())) {
          case PRMAggregate< GUM_SCALAR >::AggregateType::MIN:
          case PRMAggregate< GUM_SCALAR >::AggregateType::MAX:
          case PRMAggregate< GUM_SCALAR >::AggregateType::AMPLITUDE:
          case PRMAggregate< GUM_SCALAR >::AggregateType::MEDIAN:
          case PRMAggregate< GUM_SCALAR >::AggregateType::OR:
          case PRMAggregate< GUM_SCALAR >::AggregateType::SUM:
          case PRMAggregate< GUM_SCALAR >::AggregateType::AND: {
            ok = checkParametersNumber__(agg, 0);
            break;
          }

          case PRMAggregate< GUM_SCALAR >::AggregateType::FORALL:
          case PRMAggregate< GUM_SCALAR >::AggregateType::EXISTS:
          case PRMAggregate< GUM_SCALAR >::AggregateType::COUNT: {
            ok = checkParametersNumber__(agg, 1);
            break;
          }

          default: {
            GUM_ERROR(FatalError, "unknown aggregate type");
          }
        }

        if (!ok) { return false; }

        // Checking parameters type
        switch (gum::prm::PRMAggregate< GUM_SCALAR >::str2enum(
           agg.aggregateType().label())) {
          case PRMAggregate< GUM_SCALAR >::AggregateType::FORALL:
          case PRMAggregate< GUM_SCALAR >::AggregateType::EXISTS:
          case PRMAggregate< GUM_SCALAR >::AggregateType::COUNT: {
            ok = checkParameterValue__(agg, *t);
            break;
          }

          default: { /* Nothing to do */
          }
        }

        return ok;
      }

checkAggParents__()

template<typename GUM_SCALAR >

INLINE const PRMType * gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAggParents__ ( O3Class &  o3class, O3Aggregate &  agg  )

private

Definition at line 974 of file O3ClassFactory_tpl.h.

                                                                           {
        const auto& c = prm__->getClass(o3class.name().label());
        auto        t = (const PRMType*)nullptr;

        for (const auto& prnt: agg.parents()) {
          auto elt = resolveSlotChain__(c, prnt);

          if (elt == nullptr) {
            O3PRM_CLASS_PARENT_NOT_FOUND(prnt, *errors__);
            return nullptr;

          } else {
            if (t == nullptr) {
              try {
                t = &(elt->type());

              } catch (OperationNotAllowed&) {
                O3PRM_CLASS_WRONG_PARENT(prnt, *errors__);
                return nullptr;
              }

            } else if ((*t) != elt->type()) {
              // Wront type in chain
              O3PRM_CLASS_WRONG_PARENT_TYPE(prnt,
                                            t->name(),
                                            elt->type().name(),
                                            *errors__);
              return nullptr;
            }
          }
        }
        return t;
      }

checkAggregateForCompletion__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAggregateForCompletion__ ( O3Class &  o3class, O3Aggregate &  agg  )

private

Definition at line 574 of file O3ClassFactory_tpl.h.

                           {
        // Checking parents
        auto t = checkAggParents__(c, agg);
        if (t == nullptr) { return false; }

        // Checking parameters numbers
        if (!checkAggParameters__(c, agg, t)) { return false; }

        return true;
      }

checkAggregateForDeclaration__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAggregateForDeclaration__ ( O3Class &  o3class, O3Aggregate &  agg  )

private

Definition at line 961 of file O3ClassFactory_tpl.h.

                           {
        if (!solver__->resolveType(agg.variableType())) { return false; }

        // Checking type legality if overload
        if (!checkAggTypeLegality__(o3class, agg)) { return false; }

        return true;
      }

checkAggTypeLegality__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAggTypeLegality__ ( O3Class &  o3class, O3Aggregate &  agg  )

private

Definition at line 1011 of file O3ClassFactory_tpl.h.

                                                                                {
        if (prm__->isClass(o3class.superLabel().label())) {
          const auto& super    = prm__->getClass(o3class.superLabel().label());
          const auto& agg_type = prm__->type(agg.variableType().label());

          if (super.exists(agg.name().label())
              && !agg_type.isSubTypeOf(super.get(agg.name().label()).type())) {
            O3PRM_CLASS_ILLEGAL_OVERLOAD(agg.name(),
                                         o3class.superLabel(),
                                         *errors__);
            return false;
          }
        }

        return true;
      }

checkAndAddArcsToDag__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAndAddArcsToDag__ ( )

private

Definition at line 168 of file O3ClassFactory_tpl.h.

                                                                       {
        for (auto& c: o3_prm__->classes()) {
          if (c->superLabel().label() != "") {
            if (!solver__->resolveClass(c->superLabel())) { return false; }

            auto head = nameMap__[c->superLabel().label()];
            auto tail = nameMap__[c->name().label()];

            try {
              dag__.addArc(tail, head);
            } catch (InvalidDirectedCycle&) {
              // Cyclic inheritance
              O3PRM_CLASS_CYLIC_INHERITANCE(c->name(), c->superLabel(), *errors__);
              return false;
            }
          }
        }

        return true;
      }

checkAndAddNodesToDag__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAndAddNodesToDag__ ( )

private

Definition at line 149 of file O3ClassFactory_tpl.h.

                                                                        {
        for (auto& c: o3_prm__->classes()) {
          auto id = dag__.addNode();

          try {
            nameMap__.insert(c->name().label(), id);
            classMap__.insert(c->name().label(), c.get());
            nodeMap__.insert(id, c.get());

          } catch (DuplicateElement&) {
            O3PRM_CLASS_DUPLICATE(c->name(), *errors__);
            return false;
          }
        }

        return true;
      }

checkAttributeForCompletion__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAttributeForCompletion__ ( const O3Class &  o3_c, O3Attribute &  attr  )

private

Definition at line 634 of file O3ClassFactory_tpl.h.

                              {
        // Check for parents existence
        const auto& c = prm__->getClass(o3_c.name().label());
        for (auto& prnt: attr.parents()) {
          if (!checkParent__(c, prnt)) { return false; }
        }

        // Check that CPT sums to 1
        auto raw = dynamic_cast< O3RawCPT* >(&attr);
        if (raw) { return checkRawCPT__(c, *raw); }

        auto rule = dynamic_cast< O3RuleCPT* >(&attr);
        if (rule) { return checkRuleCPT__(c, *rule); }

        return true;
      }

checkAttributeForDeclaration__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkAttributeForDeclaration__ ( O3Class &  o3_c, O3Attribute &  attr  )

private

Definition at line 474 of file O3ClassFactory_tpl.h.

                            {
        // Check type
        if (!solver__->resolveType(attr.type())) { return false; }

        // Checking type legality if overload
        if (c.superLabel().label() != "") {
          const auto& super = prm__->getClass(c.superLabel().label());

          if (!super.exists(attr.name().label())) { return true; }

          const auto& super_type = super.get(attr.name().label()).type();
          const auto& type       = prm__->type(attr.type().label());

          if (!type.isSubTypeOf(super_type)) {
            O3PRM_CLASS_ILLEGAL_OVERLOAD(attr.name(), c.superLabel(), *errors__);
            return false;
          }
        }
        return true;
      }

checkImplementation__() [1/4]

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkImplementation__ ( O3Class &  c )

private

Definition at line 203 of file O3ClassFactory_tpl.h.

                                                                                {
        // Saving attributes names for fast lookup
        auto attr_map = AttrMap();
        for (auto& a: c.attributes()) {
          attr_map.insert(a->name().label(), a.get());
        }

        // Saving aggregates names for fast lookup
        auto agg_map = AggMap();
        for (auto& agg: c.aggregates()) {
          agg_map.insert(agg.name().label(), &agg);
        }

        auto ref_map = RefMap();
        for (auto& ref: c.referenceSlots()) {
          ref_map.insert(ref.name().label(), &ref);
        }

        // Cheking interface implementation
        for (auto& i: c.interfaces()) {
          if (solver__->resolveInterface(i)) {
            if (!checkImplementation__(c, i, attr_map, agg_map, ref_map)) {
              return false;
            }
          }
        }

        return true;
      }

checkImplementation__() [2/4]

template<typename GUM_SCALAR >

bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkImplementation__ ( O3Class &  c, O3Label &  i, HashTable< std::string, O3Attribute * > &  attrMap, HashTable< std::string, O3Aggregate * > &  aggMap, HashTable< std::string, O3ReferenceSlot * > &  refMap  )

private

checkImplementation__() [3/4]

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkImplementation__ ( O3Label &  o3_type, const PRMType &  type  )

private

Definition at line 295 of file O3ClassFactory_tpl.h.

                                                                                  {
        if (!solver__->resolveType(o3_type)) { return false; }

        return prm__->type(o3_type.label()).isSubTypeOf(type);
      }

checkImplementation__() [4/4]

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkImplementation__ ( O3Label &  o3_type, const PRMClassElementContainer< GUM_SCALAR > &  type  )

private

Definition at line 303 of file O3ClassFactory_tpl.h.

                                                             {
        if (!solver__->resolveSlotType(o3_type)) { return false; }

        if (prm__->isInterface(o3_type.label())) {
          return prm__->getInterface(o3_type.label()).isSubTypeOf(type);
        } else {
          return prm__->getClass(o3_type.label()).isSubTypeOf(type);
        }
      }

checkLabelsNumber__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkLabelsNumber__ ( const O3RuleCPT &  attr, const O3RuleCPT::O3Rule &  rule  )

private

Definition at line 694 of file O3ClassFactory_tpl.h.

                                      {
        // Check that the number of labels is correct
        if (rule.first.size() != attr.parents().size()) {
          O3PRM_CLASS_ILLEGAL_RULE_SIZE(rule,
                                        rule.first.size(),
                                        attr.parents().size(),
                                        *errors__);
          return false;
        }
        return true;
      }

checkLabelsValues__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkLabelsValues__ ( const PRMClass< GUM_SCALAR > &  c, const O3RuleCPT &  attr, const O3RuleCPT::O3Rule &  rule  )

private

Definition at line 709 of file O3ClassFactory_tpl.h.

                                           {
        bool errors = false;
        for (std::size_t i = 0; i < attr.parents().size(); ++i) {
          auto label = rule.first[i];
          auto prnt  = attr.parents()[i];
          try {
            auto real_labels = resolveSlotChain__(c, prnt)->type()->labels();
            // c.get(prnt.label()).type()->labels();
            if (label.label() != "*"
                && std::find(real_labels.begin(), real_labels.end(), label.label())
                      == real_labels.end()) {
              O3PRM_CLASS_ILLEGAL_RULE_LABEL(rule, label, prnt, *errors__);
              errors = true;
            }
          } catch (Exception&) {
            // parent does not exists and is already reported
          }
        }
        return errors == false;
      }

checkLocalParent__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkLocalParent__ ( const PRMClass< GUM_SCALAR > &  c, const O3Label &  prnt  )

private

Definition at line 666 of file O3ClassFactory_tpl.h.

                                             {
        if (!c.exists(prnt.label())) {
          O3PRM_CLASS_PARENT_NOT_FOUND(prnt, *errors__);
          return false;
        }

        const auto& elt = c.get(prnt.label());
        if (!(gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(elt)
              || gum::prm::PRMClassElement< GUM_SCALAR >::isSlotChain(elt)
              || gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(elt))) {
          O3PRM_CLASS_ILLEGAL_PARENT(prnt, *errors__);
          return false;
        }

        return true;
      }

checkO3Classes__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkO3Classes__ ( )

private

Definition at line 144 of file O3ClassFactory_tpl.h.

                                                                 {
        return checkAndAddNodesToDag__() && checkAndAddArcsToDag__();
      }

checkParametersNumber__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkParametersNumber__ ( O3Aggregate &  agg, Size  n  )

private

Definition at line 1082 of file O3ClassFactory_tpl.h.

                                                                               {
        if (agg.parameters().size() != n) {
          O3PRM_CLASS_AGG_PARAMETERS(agg.name(),
                                     Size(n),
                                     Size(agg.parameters().size()),
                                     *errors__);
          return false;
        }

        return true;
      }

checkParameterValue__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkParameterValue__ ( O3Aggregate &  agg, const gum::prm::PRMType &  t  )

private

Definition at line 1096 of file O3ClassFactory_tpl.h.

                                 {
        const auto& param = agg.parameters().front();
        bool        found = false;
        for (Size idx = 0; idx < t.variable().domainSize(); ++idx) {
          if (t.variable().label(idx) == param.label()) {
            found = true;
            break;
          }
        }

        if (!found) {
          O3PRM_CLASS_AGG_PARAMETER_NOT_FOUND(agg.name(), param, *errors__);
          return false;
        }

        return true;
      }

checkParent__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkParent__ ( const PRMClass< GUM_SCALAR > &  c, const O3Label &  prnt  )

private

Definition at line 654 of file O3ClassFactory_tpl.h.

                                             {
        if (prnt.label().find('.') == std::string::npos) {
          return checkLocalParent__(c, prnt);

        } else {
          return checkRemoteParent__(c, prnt);
        }
      }

checkRawCPT__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkRawCPT__ ( const PRMClass< GUM_SCALAR > &  c, O3RawCPT &  attr  )

private

Definition at line 807 of file O3ClassFactory_tpl.h.

                                             {
        const auto& type = prm__->type(attr.type().label());

        auto domainSize = type->domainSize();
        for (auto& prnt: attr.parents()) {
          try {
            domainSize *= c.get(prnt.label()).type()->domainSize();
          } catch (NotFound&) {
            // If we are here, all parents have been check so resolveSlotChain__
            // will not raise an error and not return a nullptr
            domainSize *= resolveSlotChain__(c, prnt)->type()->domainSize();
          }
        }

        // Check for CPT size
        if (domainSize != attr.values().size()) {
          O3PRM_CLASS_ILLEGAL_CPT_SIZE(c.name(),
                                       attr.name(),
                                       Size(attr.values().size()),
                                       domainSize,
                                       *errors__);
          return false;
        }

        // Add parameters to formulas
        const auto& scope = c.scope();
        for (auto& f: attr.values()) {
          f.formula().variables().clear();

          for (const auto& values: scope) {
            f.formula().variables().insert(values.first, values.second->value());
          }
        }

        // Check that CPT sums to 1
        Size parent_size = domainSize / type->domainSize();
        auto values      = std::vector< GUM_SCALAR >(parent_size, 0.0f);

        for (std::size_t i = 0; i < attr.values().size(); ++i) {
          try {
            auto idx = i % parent_size;
            auto val = (GUM_SCALAR)attr.values()[i].formula().result();
            values[idx] += val;

            if (val < 0.0 || 1.0 < val) {
              O3PRM_CLASS_ILLEGAL_CPT_VALUE(c.name(),
                                            attr.name(),
                                            attr.values()[i],
                                            *errors__);
              return false;
            }
          } catch (Exception&) {
            O3PRM_CLASS_ILLEGAL_CPT_VALUE(c.name(),
                                          attr.name(),
                                          attr.values()[i],
                                          *errors__);
            return false;
          }
        }

        for (auto f: values) {
          if (std::abs(f - GUM_SCALAR(1.0)) > 1.0e-3) {
            O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1(c.name(),
                                              attr.name(),
                                              float(f),
                                              *errors__);
            return false;
          } else if (std::abs(f - GUM_SCALAR(1.0)) > 1.0e-6) {
            O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1_WARNING(c.name(),
                                                      attr.name(),
                                                      float(f),
                                                      *errors__);
          }
        }
        return true;
      }

checkReferenceSlot__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkReferenceSlot__ ( O3Class &  c, O3ReferenceSlot &  ref  )

private

Definition at line 382 of file O3ClassFactory_tpl.h.

                                                                                  {
        if (!solver__->resolveSlotType(ref.type())) { return false; }

        const auto& real_c = prm__->getClass(c.name().label());

        // Check for dupplicates
        if (real_c.exists(ref.name().label())) {
          const auto& elt = real_c.get(ref.name().label());

          if (PRMClassElement< GUM_SCALAR >::isReferenceSlot(elt)) {
            auto slot_type = (PRMClassElementContainer< GUM_SCALAR >*)nullptr;

            if (prm__->isInterface(ref.type().label())) {
              slot_type = &(prm__->getInterface(ref.type().label()));

            } else {
              slot_type = &(prm__->getClass(ref.type().label()));
            }

            auto real_ref
               = static_cast< const PRMReferenceSlot< GUM_SCALAR >* >(&elt);

            if (slot_type->name() == real_ref->slotType().name()) {
              O3PRM_CLASS_DUPLICATE_REFERENCE(ref.name(), *errors__);
              return false;

            } else if (!slot_type->isSubTypeOf(real_ref->slotType())) {
              O3PRM_CLASS_ILLEGAL_OVERLOAD(ref.name(), c.name(), *errors__);
              return false;
            }

          } else {
            O3PRM_CLASS_DUPLICATE_REFERENCE(ref.name(), *errors__);
            return false;
          }
        }

        // If class we need to check for illegal references
        if (prm__->isClass(ref.type().label())) {
          const auto& ref_type = prm__->getClass(ref.type().label());

          // No recursive reference
          if ((&ref_type) == (&real_c)) {
            O3PRM_CLASS_SELF_REFERENCE(c.name(), ref.name(), *errors__);
            return false;
          }

          // No reference to subclasses
          if (ref_type.isSubTypeOf(real_c)) {
            O3PRM_CLASS_ILLEGAL_SUB_REFERENCE(c.name(), ref.type(), *errors__);
            return false;
          }
        }

        return true;
      }

checkRemoteParent__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkRemoteParent__ ( const PRMClassElementContainer< GUM_SCALAR > &  c, const O3Label &  prnt  )

private

Definition at line 686 of file O3ClassFactory_tpl.h.

                                                             {
        if (resolveSlotChain__(c, prnt) == nullptr) { return false; }
        return true;
      }

checkRuleCPT__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkRuleCPT__ ( const PRMClass< GUM_SCALAR > &  c, O3RuleCPT &  attr  )

private

Definition at line 786 of file O3ClassFactory_tpl.h.

                                             {
        const auto& scope  = c.scope();
        bool        errors = false;
        for (auto& rule: attr.rules()) {
          try {
            if (!checkLabelsNumber__(attr, rule)) { errors = true; }
            if (!checkLabelsValues__(c, attr, rule)) { errors = true; }
            addParamsToForms__(scope, rule);
            if (!checkRuleCPTSumsTo1__(c, attr, rule)) { errors = true; }
          } catch (Exception& e) {
            GUM_SHOWERROR(e);
            errors = true;
          }
        }

        return errors == false;
      }

checkRuleCPTSumsTo1__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkRuleCPTSumsTo1__ ( const PRMClass< GUM_SCALAR > &  c, const O3RuleCPT &  attr, const O3RuleCPT::O3Rule &  rule  )

private

Definition at line 748 of file O3ClassFactory_tpl.h.

                                           {
        bool errors = false;
        // Check that formulas are valid and sums to 1
        GUM_SCALAR sum = 0.0;
        for (const auto& f: rule.second) {
          try {
            auto value = GUM_SCALAR(f.formula().result());
            sum += value;
            if (value < 0.0 || 1.0 < value) {
              O3PRM_CLASS_ILLEGAL_CPT_VALUE(c.name(), attr.name(), f, *errors__);
              errors = true;
            }
          } catch (OperationNotAllowed&) {
            O3PRM_CLASS_ILLEGAL_CPT_VALUE(c.name(), attr.name(), f, *errors__);
            errors = true;
          }
        }

        // Check that CPT sums to 1
        if (std::abs(sum - 1.0) > 1e-3) {
          O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1(c.name(),
                                            attr.name(),
                                            float(sum),
                                            *errors__);
          errors = true;
        } else if (std::abs(sum - 1.0f) > 1e-6) {
          O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1_WARNING(c.name(),
                                                    attr.name(),
                                                    float(sum),
                                                    *errors__);
        }
        return errors == false;
      }

checkSlotChainLink__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::checkSlotChainLink__ ( const PRMClassElementContainer< GUM_SCALAR > &  c, const O3Label &  chain, const std::string &  s  )

private

Definition at line 926 of file O3ClassFactory_tpl.h.

                                                        {
        if (!c.exists(s)) {
          O3PRM_CLASS_LINK_NOT_FOUND(chain, s, *errors__);
          return false;
        }
        return true;
      }

completeAggregates()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates

(

)

Definition at line 542 of file O3ClassFactory_tpl.h.

                                                                   {
        PRMFactory< GUM_SCALAR > factory(prm__);

        // Class with a super class must be declared in order
        for (auto c: o3Classes__) {
          factory.continueClass(c->name().label());

          completeAggregates__(factory, *c);

          factory.endClass(false);
        }
      }

completeAggregates__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAggregates__ ( PRMFactory< GUM_SCALAR > &  factory, O3Class &  c  )

private

Definition at line 556 of file O3ClassFactory_tpl.h.

                                      {
        // Attributes
        for (auto& agg: c.aggregates()) {
          if (checkAggregateForCompletion__(c, agg)) {
            factory.continueAggregator(agg.name().label());

            for (const auto& parent: agg.parents()) {
              factory.addParent(parent.label());
            }

            factory.endAggregator();
          }
        }
      }

completeAttribute__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttribute__ ( PRMFactory< GUM_SCALAR > &  factory, O3Class &  c  )

private

Definition at line 588 of file O3ClassFactory_tpl.h.

                                      {
        // Attributes
        for (auto& attr: c.attributes()) {
          if (checkAttributeForCompletion__(c, *attr)) {
            factory.continueAttribute(attr->name().label());

            for (const auto& parent: attr->parents()) {
              factory.addParent(parent.label());
            }

            auto raw = dynamic_cast< const O3RawCPT* >(attr.get());

            if (raw) {
              auto values = std::vector< std::string >();
              for (const auto& val: raw->values()) {
                values.push_back(val.formula().formula());
              }
              factory.setRawCPFByColumns(values);
            }

            auto rule_cpt = dynamic_cast< const O3RuleCPT* >(attr.get());
            if (rule_cpt) {
              for (const auto& rule: rule_cpt->rules()) {
                auto labels = std::vector< std::string >();
                auto values = std::vector< std::string >();

                for (const auto& lbl: rule.first) {
                  labels.push_back(lbl.label());
                }

                for (const auto& form: rule.second) {
                  values.push_back(form.formula().formula());
                }

                factory.setCPFByRule(labels, values);
              }
            }

            factory.endAttribute();
          }
        }
      }

completeAttributes()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::completeAttributes

(

)

Definition at line 498 of file O3ClassFactory_tpl.h.

                                                                   {
        PRMFactory< GUM_SCALAR > factory(prm__);

        // Class with a super class must be declared in order
        for (auto c: o3Classes__) {
          prm__->getClass(c->name().label()).inheritSlotChains();
          factory.continueClass(c->name().label());

          completeAttribute__(factory, *c);

          if (c->superLabel().label() != "") {
            auto& super       = prm__->getClass(c->superLabel().label());
            auto  to_complete = Set< std::string >();

            for (auto a: super.attributes()) {
              to_complete.insert(a->safeName());
            }

            for (auto a: super.aggregates()) {
              to_complete.insert(a->safeName());
            }

            for (auto& a: c->attributes()) {
              to_complete.erase(prm__->getClass(c->name().label())
                                   .get(a->name().label())
                                   .safeName());
            }

            for (auto& a: c->aggregates()) {
              to_complete.erase(prm__->getClass(c->name().label())
                                   .get(a.name().label())
                                   .safeName());
            }

            for (auto a: to_complete) {
              prm__->getClass(c->name().label()).completeInheritance(a);
            }
          }

          factory.endClass(true);
        }
      }

declareAggregates()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::declareAggregates

(

)

Definition at line 450 of file O3ClassFactory_tpl.h.

                                                                  {
        // Class with a super class must be declared after
        for (auto c: o3Classes__) {
          prm__->getClass(c->name().label()).inheritAggregates();
          declareAggregates__(*c);
        }
      }

declareAggregates__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::declareAggregates__ ( O3Class &  c )

private

Definition at line 938 of file O3ClassFactory_tpl.h.

                                                                              {
        PRMFactory< GUM_SCALAR > factory(prm__);
        factory.continueClass(c.name().label());

        for (auto& agg: c.aggregates()) {
          if (checkAggregateForDeclaration__(c, agg)) {
            auto params = std::vector< std::string >();
            for (auto& p: agg.parameters()) {
              params.push_back(p.label());
            }

            factory.startAggregator(agg.name().label(),
                                    agg.aggregateType().label(),
                                    agg.variableType().label(),
                                    params);
            factory.endAggregator();
          }
        }

        factory.endClass(false);
      }

declareAttribute__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::declareAttribute__ ( O3Class &  c )

private

Definition at line 459 of file O3ClassFactory_tpl.h.

                                                                             {
        PRMFactory< GUM_SCALAR > factory(prm__);
        factory.continueClass(c.name().label());

        for (auto& attr: c.attributes()) {
          if (checkAttributeForDeclaration__(c, *attr)) {
            factory.startAttribute(attr->type().label(), attr->name().label());
            factory.endAttribute();
          }
        }

        factory.endClass(false);
      }

declareAttributes()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::declareAttributes

(

)

Definition at line 441 of file O3ClassFactory_tpl.h.

                                                                  {
        // Class with a super class must be declared after
        for (auto c: o3Classes__) {
          prm__->getClass(c->name().label()).inheritAttributes();
          declareAttribute__(*c);
        }
      }

operator=() [1/2]

template<typename GUM_SCALAR >

INLINE O3ClassFactory< GUM_SCALAR > & gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::operator=

(

const O3ClassFactory< GUM_SCALAR > &

src

)

Definition at line 76 of file O3ClassFactory_tpl.h.

                                                  {
        if (this == &src) { return *this; }
        prm__       = src.prm__;
        o3_prm__    = src.o3_prm__;
        solver__    = src.solver__;
        errors__    = src.errors__;
        nameMap__   = src.nameMap__;
        classMap__  = src.classMap__;
        nodeMap__   = src.nodeMap__;
        dag__       = src.dag__;
        o3Classes__ = src.o3Classes__;
        return *this;
      }

operator=() [2/2]

template<typename GUM_SCALAR >

INLINE O3ClassFactory< GUM_SCALAR > & gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::operator=

(

O3ClassFactory< GUM_SCALAR > &&

src

)

Definition at line 92 of file O3ClassFactory_tpl.h.

                                             {
        if (this == &src) { return *this; }
        prm__       = std::move(src.prm__);
        o3_prm__    = std::move(src.o3_prm__);
        solver__    = std::move(src.solver__);
        errors__    = std::move(src.errors__);
        nameMap__   = std::move(src.nameMap__);
        classMap__  = std::move(src.classMap__);
        nodeMap__   = std::move(src.nodeMap__);
        dag__       = std::move(src.dag__);
        o3Classes__ = std::move(src.o3Classes__);
        return *this;
      }

resolveSlotChain__()

template<typename GUM_SCALAR >

INLINE const PRMClassElement< GUM_SCALAR > * gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::resolveSlotChain__ ( const PRMClassElementContainer< GUM_SCALAR > &  c, const O3Label &  chain  )

private

Definition at line 888 of file O3ClassFactory_tpl.h.

                                                                 {
        auto                       s       = chain.label();
        auto                       current = &c;
        std::vector< std::string > v;

        decomposePath(chain.label(), v);

        for (size_t i = 0; i < v.size(); ++i) {
          auto link = v[i];

          if (!checkSlotChainLink__(*current, chain, link)) { return nullptr; }

          auto elt = &(current->get(link));

          if (i == v.size() - 1) {
            // last link, should be an attribute or aggregate
            return elt;

          } else {
            // should be a reference slot

            auto ref = dynamic_cast< const PRMReferenceSlot< GUM_SCALAR >* >(elt);
            if (ref) {
              current = &(ref->slotType());
            } else {
              return nullptr;   // failsafe to prevent infinite loop
            }
          }
        }

        // Encountered only reference slots

        return nullptr;
      }

setO3ClassCreationOrder__()

template<typename GUM_SCALAR >

INLINE void gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::setO3ClassCreationOrder__ ( )

private

Definition at line 135 of file O3ClassFactory_tpl.h.

                                                                          {
        auto topo_order = dag__.topologicalOrder();

        for (auto id = topo_order.rbegin(); id != topo_order.rend(); --id) {
          o3Classes__.push_back(nodeMap__[*id]);
        }
      }

Member Data Documentation

classMap__

template<typename GUM_SCALAR >

HashTable< std::string, O3Class* > gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::classMap__

private

Definition at line 96 of file O3ClassFactory.h.

dag__

template<typename GUM_SCALAR >

DAG gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::dag__

private

Definition at line 98 of file O3ClassFactory.h.

errors__

template<typename GUM_SCALAR >

ErrorsContainer* gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::errors__

private

Definition at line 93 of file O3ClassFactory.h.

nameMap__

template<typename GUM_SCALAR >

HashTable< std::string, gum::NodeId > gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::nameMap__

private

Definition at line 95 of file O3ClassFactory.h.

nodeMap__

template<typename GUM_SCALAR >

HashTable< NodeId, O3Class* > gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::nodeMap__

private

Definition at line 97 of file O3ClassFactory.h.

o3_prm__

template<typename GUM_SCALAR >

O3PRM* gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::o3_prm__

private

Definition at line 91 of file O3ClassFactory.h.

o3Classes__

template<typename GUM_SCALAR >

std::vector< O3Class* > gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::o3Classes__

private

Definition at line 99 of file O3ClassFactory.h.

prm__

template<typename GUM_SCALAR >

PRM< GUM_SCALAR >* gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::prm__

private

Definition at line 90 of file O3ClassFactory.h.

solver__

template<typename GUM_SCALAR >

O3NameSolver< GUM_SCALAR >* gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::solver__

private

Definition at line 92 of file O3ClassFactory.h.

---

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

• agrum/PRM/o3prm/O3ClassFactory.h
• agrum/PRM/o3prm/O3ClassFactory_tpl.h