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

Resolves names for the different O3PRM factories. More...

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

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

Public Member Functions
	O3NameSolver (PRM< GUM_SCALAR > &prm, O3PRM &o3_prm, ErrorsContainer &errors)
	O3NameSolver (const O3NameSolver< GUM_SCALAR > &src)
	O3NameSolver (O3NameSolver< GUM_SCALAR > &&src)
	~O3NameSolver ()
O3NameSolver< GUM_SCALAR > &	operator= (const O3NameSolver< GUM_SCALAR > &src)
O3NameSolver< GUM_SCALAR > &	operator= (O3NameSolver< GUM_SCALAR > &&src)
bool	resolveClassElement (O3Label &name)
bool	resolveType (O3Label &name)
bool	resolveInterface (O3Label &name)
bool	resolveClass (O3Label &name)
bool	resolveSlotType (O3Label &name)

Detailed Description

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

Resolves names for the different O3PRM factories.

Template Parameters

GUM_SCALAR

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

Definition at line 56 of file O3NameSolver.h.

Member Typedef Documentation

NameMap

template<typename GUM_SCALAR >

using gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::NameMap = HashTable< std::string, std::string >

private

Definition at line 88 of file O3NameSolver.h.

Constructor & Destructor Documentation

O3NameSolver() [1/3]

template<typename GUM_SCALAR >

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

Definition at line 37 of file O3NameSolver_tpl.h.

                                                                                 :
          prm__(&prm),
          o3_prm__(&o3_prm), errors__(&errors) {
        GUM_CONSTRUCTOR(O3NameSolver);
      }

O3NameSolver() [2/3]

template<typename GUM_SCALAR >

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

(

const O3NameSolver< GUM_SCALAR > &

src

)

Definition at line 46 of file O3NameSolver_tpl.h.

                                                :
          prm__(src.prm__),
          o3_prm__(src.o3_prm__), errors__(src.errors__),
          typeName__(src.typeName__), eltName__(src.eltName__),
          refName__(src.refName__), interfaceName__(src.interfaceName__),
          className__(src.className__) {
        GUM_CONS_CPY(O3NameSolver);
      }

O3NameSolver() [3/3]

template<typename GUM_SCALAR >

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

(

O3NameSolver< GUM_SCALAR > &&

src

)

Definition at line 57 of file O3NameSolver_tpl.h.

                                           :
          prm__(std::move(src.prm__)),
          o3_prm__(std::move(src.o3_prm__)), errors__(std::move(src.errors__)),
          typeName__(std::move(src.typeName__)),
          eltName__(std::move(src.eltName__)), refName__(std::move(src.refName__)),
          interfaceName__(std::move(src.interfaceName__)),
          className__(std::move(src.className__)) {
        GUM_CONS_MOV(O3NameSolver);
      }

~O3NameSolver()

template<typename GUM_SCALAR >

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

(

)

Definition at line 69 of file O3NameSolver_tpl.h.

                                                       {
        GUM_DESTRUCTOR(O3NameSolver);
      }

Member Function Documentation

operator=() [1/2]

template<typename GUM_SCALAR >

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

(

const O3NameSolver< GUM_SCALAR > &

src

)

Definition at line 74 of file O3NameSolver_tpl.h.

                                                {
        if (this == &src) { return *this; }
        prm__           = src.prm__;
        o3_prm__        = src.o3_prm__;
        errors__        = src.errors__;
        typeName__      = src.typeName__;
        eltName__       = src.eltName__;
        refName__       = src.refName__;
        interfaceName__ = src.interfaceName__;
        className__     = src.className__;
        return *this;
      }

operator=() [2/2]

template<typename GUM_SCALAR >

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

(

O3NameSolver< GUM_SCALAR > &&

src

)

Definition at line 90 of file O3NameSolver_tpl.h.

                                                                               {
        if (this == &src) { return *this; }
        prm__           = std::move(src.prm__);
        o3_prm__        = std::move(src.o3_prm__);
        errors__        = std::move(src.errors__);
        typeName__      = std::move(src.typeName__);
        eltName__       = std::move(src.eltName__);
        refName__       = std::move(src.refName__);
        interfaceName__ = std::move(src.interfaceName__);
        className__     = std::move(src.className__);
        return *this;
      }

resolveClass()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveClass

(

O3Label &

name

)

Definition at line 370 of file O3NameSolver_tpl.h.

                                                                        {
        // If empty string, we return an empty string
        if (name.label() == "") { return true; }

        // If we've already found super real name
        if (className__.exists(name.label())) {
          name.label() = className__[name.label()];
          return true;
        }

        // If class name exists as is
        if (prm__->isClass(name.label())) {
          className__.insert(name.label(), name.label());
          return true;
        }

        for (auto& c: o3_prm__->classes()) {
          if (c->name().label() == name.label()) {
            className__.insert(name.label(), name.label());
            return true;
          }
        }

        // If we didn't find it as is, then we must find a namespace
        // in which it was declared
        auto lookup  = "." + name.label();
        auto matches = std::vector< std::string >();
        auto found   = Set< std::string >();

        // Try to complete with Class
        for (auto c: prm__->classes()) {
          if (endsWith(c->name(), lookup)) {
            if (!found.exists(c->name())) {
              found.insert(c->name());
              matches.push_back(c->name());
            }
          }
        }

        // Try to complete with O3Class
        for (auto& c: o3_prm__->classes()) {
          if (endsWith(c->name().label(), lookup)) {
            if (!found.exists(c->name().label())) {
              found.insert(c->name().label());
              matches.push_back(c->name().label());
            }
          }
        }

        if (matches.size() == 1) {   // One match is good

          className__.insert(name.label(), matches.back());
          name.label() = matches.back();
          return true;

        } else if (matches.size() == 0) {   // 0 match is not found

          // Unknown super class
          O3PRM_CLASS_NOT_FOUND(name, *errors__);
          return false;

        } else {   // More than one match is ambiguous

          // Ambiguous name
          O3PRM_CLASS_AMBIGUOUS(name, matches, *errors__);
          return false;
        }
      }

resolveClassElement()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveClassElement

(

O3Label &

name

)

Definition at line 104 of file O3NameSolver_tpl.h.

                                                                               {
        // If empty string, we return an empty string
        if (name.label() == "") { return true; }
        // If we've already found the element real name
        if (eltName__.exists(name.label())) {
          name.label() = eltName__[name.label()];
          return true;
        }
        // If name exists as is
        if (prm__->isType(name.label())) {
          eltName__.insert(name.label(), name.label());
          return true;
        }
        // If name exists as is
        if (prm__->isInterface(name.label())) {
          eltName__.insert(name.label(), name.label());
          return true;
        }
        // If name exists as is
        if (prm__->isClass(name.label())) {
          eltName__.insert(name.label(), name.label());
          return true;
        }
        // If name exists as is in O3PRM types
        for (auto& t: o3_prm__->types()) {
          if (t->name().label() == name.label()) {
            eltName__.insert(name.label(), name.label());
            return true;
          }
        }
        // If name exists as is in O3PRM interfaces
        for (auto& i: o3_prm__->interfaces()) {
          if (i->name().label() == name.label()) {
            eltName__.insert(name.label(), name.label());
            return true;
          }
        }
        // If name exists as is in O3PRM classes
        for (auto& c: o3_prm__->classes()) {
          if (c->name().label() == name.label()) {
            eltName__.insert(name.label(), name.label());
            return true;
          }
        }

        auto lookup  = "." + name.label();
        auto found   = Set< std::string >();
        auto matches = std::vector< std::string >();

        // Trying with types
        for (auto t: prm__->types()) {
          if (endsWith(t->name(), lookup)) {
            if (!found.exists(t->name())) {
              found.insert(t->name());
              matches.push_back(t->name());
            }
          }
        }
        // Trying with O3Types
        for (auto& t: o3_prm__->types()) {
          if (endsWith(t->name().label(), lookup)) {
            if (!found.exists(t->name().label())) {
              found.insert(t->name().label());
              matches.push_back(t->name().label());
            }
          }
        }

        // Trying with interfaces
        for (auto i: prm__->interfaces()) {
          if (endsWith(i->name(), lookup)) {
            if (!found.exists(i->name())) {
              found.insert(i->name());
              matches.push_back(i->name());
            }
          }
        }
        // Trying with O3Interface
        for (auto& i: o3_prm__->interfaces()) {
          if (endsWith(i->name().label(), lookup)) {
            if (!found.exists(i->name().label())) {
              found.insert(i->name().label());
              matches.push_back(i->name().label());
            }
          }
        }

        // Trying with class
        for (auto c: prm__->classes()) {
          if (endsWith(c->name(), lookup)) {
            if (!found.exists(c->name())) {
              found.insert(c->name());
              matches.push_back(c->name());
            }
          }
        }
        // Trying with O3Class
        for (auto& c: o3_prm__->classes()) {
          if (endsWith(c->name().label(), lookup)) {
            if (!found.exists(c->name().label())) {
              found.insert(c->name().label());
              matches.push_back(c->name().label());
            }
          }
        }

        if (matches.size() == 1) {   // One match is good
          eltName__.insert(name.label(), matches.back());
          name.label() = matches.back();
          return true;

        } else if (matches.size() == 0) {   // 0 match is not found

          // Unknown name type
          O3PRM_TYPE_NOT_FOUND(name, *errors__);
          return false;

        } else {   // More than one match is ambiguous

          // Ambiguous name
          O3PRM_TYPE_AMBIGUOUS(name, matches, *errors__);
          return false;
        }
      }

resolveInterface()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveInterface

(

O3Label &

name

)

Definition at line 300 of file O3NameSolver_tpl.h.

                                                                            {
        // If empty string, we return an empty string
        if (name.label() == "") { return true; }

        // If we've already found the interface real name
        if (interfaceName__.exists(name.label())) {
          name.label() = interfaceName__[name.label()];
          return true;
        }

        // If name exists as is
        if (prm__->isInterface(name.label())) {
          interfaceName__.insert(name.label(), name.label());
          return true;
        }

        for (auto& i: o3_prm__->interfaces()) {
          if (i->name().label() == name.label()) {
            interfaceName__.insert(name.label(), name.label());
            return true;
          }
        }

        // If we didn't find it as is, then we must find a namespace
        // in which it was declared
        auto lookup  = "." + name.label();
        auto found   = Set< std::string >();
        auto matches = std::vector< std::string >();

        // Trying with interfaces
        for (auto i: prm__->interfaces()) {
          if (endsWith(i->name(), lookup)) {
            if (!found.exists(i->name())) {
              found.insert(i->name());
              matches.push_back(i->name());
            }
          }
        }

        // Trying with O3Interface
        for (auto& i: o3_prm__->interfaces()) {
          if (endsWith(i->name().label(), lookup)) {
            if (!found.exists(i->name().label())) {
              found.insert(i->name().label());
              matches.push_back(i->name().label());
            }
          }
        }

        if (matches.size() == 1) {   // One match is good

          interfaceName__.insert(name.label(), matches.back());
          name.label() = matches.back();
          return true;

        } else if (matches.size() == 0) {   // 0 match is not found

          // Unknown name type
          O3PRM_INTERFACE_NOT_FOUND(name, *errors__);
          return false;

        } else {   // More than one match is ambiguous

          // Ambiguous name
          O3PRM_INTERFACE_AMBIGUOUS(name, matches, *errors__);
          return false;
        }
      }

resolveSlotType()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveSlotType

(

O3Label &

name

)

Definition at line 440 of file O3NameSolver_tpl.h.

                                                                           {
        // If empty string, we return an empty string
        if (name.label() == "") { return true; }
        // If we've already found the reference real name
        if (refName__.exists(name.label())) {
          name.label() = refName__[name.label()];
          return true;
        }
        // If name exists as is
        if (prm__->isInterface(name.label()) || prm__->isClass(name.label())) {
          refName__.insert(name.label(), name.label());
          return true;
        }

        // We check if it matches an O3Interface
        for (auto& i: o3_prm__->interfaces()) {
          if (i->name().label() == name.label()) {
            interfaceName__.insert(name.label(), name.label());
            return true;
          }
        }

        // We check if it matches an O3Class
        for (auto& c: o3_prm__->classes()) {
          if (c->name().label() == name.label()) {
            className__.insert(name.label(), name.label());
            return true;
          }
        }

        // If we didn't find it as is, then we must find a namespace
        // in which it was declared
        auto lookup  = "." + name.label();
        auto found   = Set< std::string >();
        auto matches = std::vector< std::string >();

        // Trying with interfaces
        for (auto i: prm__->interfaces()) {
          if (endsWith(i->name(), lookup)) {
            if (!found.exists(i->name())) {
              found.insert(i->name());
              matches.push_back(i->name());
            }
          }
        }

        // Trying with O3Interface
        for (auto& i: o3_prm__->interfaces()) {
          if (endsWith(i->name().label(), lookup)) {
            if (!found.exists(i->name().label())) {
              found.insert(i->name().label());
              matches.push_back(i->name().label());
            }
          }
        }

        // Try to complete with Class
        for (auto c: prm__->classes()) {
          if (endsWith(c->name(), lookup)) {
            if (!found.exists(c->name())) {
              found.insert(c->name());
              matches.push_back(c->name());
            }
          }
        }

        // Try to complete with O3Class
        for (auto& c: o3_prm__->classes()) {
          if (endsWith(c->name().label(), lookup)) {
            if (!found.exists(c->name().label())) {
              found.insert(c->name().label());
              matches.push_back(c->name().label());
            }
          }
        }

        if (matches.size() == 1) {   // One match is good

          refName__.insert(name.label(), matches.back());
          name.label() = matches.back();
          return true;

        } else if (matches.size() == 0) {   // 0 match is not found

          // Unknown name type
          O3PRM_REFERENCE_NOT_FOUND(name, *errors__);
          return false;

        } else {   // More than one match is ambiguous

          // Ambiguous name
          O3PRM_REFERENCE_AMBIGUOUS(name, matches, *errors__);
          return false;
        }
      }

resolveType()

template<typename GUM_SCALAR >

INLINE bool gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::resolveType

(

O3Label &

name

)

Definition at line 230 of file O3NameSolver_tpl.h.

                                                                       {
        // If empty string, we return an empty string
        if (name.label() == "") { return true; }

        // If we've already found the type real name
        if (typeName__.exists(name.label())) {
          name.label() = typeName__[name.label()];
          return true;
        }

        // If name exists as is in PRM
        if (prm__->isType(name.label())) {
          typeName__.insert(name.label(), name.label());
          return true;
        }

        // If name exists as is in O3PRM
        for (auto& t: o3_prm__->types()) {
          if (t->name().label() == name.label()) {
            typeName__.insert(name.label(), name.label());
            return true;
          }
        }

        // If we didn't find it as is, then we must find a namespace
        // in which it was declared
        auto lookup  = "." + name.label();
        auto found   = Set< std::string >();
        auto matches = std::vector< std::string >();

        // Trying with types
        for (auto t: prm__->types()) {
          if (endsWith(t->name(), lookup)) {
            if (!found.exists(t->name())) {
              found.insert(t->name());
              matches.push_back(t->name());
            }
          }
        }

        // Trying with O3Types
        for (auto& t: o3_prm__->types()) {
          if (endsWith(t->name().label(), lookup)) {
            if (!found.exists(t->name().label())) {
              found.insert(t->name().label());
              matches.push_back(t->name().label());
            }
          }
        }

        if (matches.size() == 1) {   // One match is good
          typeName__.insert(name.label(), matches.back());
          name.label() = matches.back();
          return true;

        } else if (matches.size() == 0) {   // 0 match is not found

          // Unknown name type
          O3PRM_TYPE_NOT_FOUND(name, *errors__);
          return false;

        } else {   // More than one match is ambiguous

          // Ambiguous name
          O3PRM_TYPE_AMBIGUOUS(name, matches, *errors__);
          return false;
        }
      }

Member Data Documentation

className__

template<typename GUM_SCALAR >

NameMap gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::className__

private

Definition at line 94 of file O3NameSolver.h.

eltName__

template<typename GUM_SCALAR >

NameMap gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::eltName__

private

Definition at line 91 of file O3NameSolver.h.

errors__

template<typename GUM_SCALAR >

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

private

Definition at line 86 of file O3NameSolver.h.

interfaceName__

template<typename GUM_SCALAR >

NameMap gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::interfaceName__

private

Definition at line 93 of file O3NameSolver.h.

o3_prm__

template<typename GUM_SCALAR >

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

private

Definition at line 85 of file O3NameSolver.h.

prm__

template<typename GUM_SCALAR >

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

private

Definition at line 84 of file O3NameSolver.h.

refName__

template<typename GUM_SCALAR >

NameMap gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::refName__

private

Definition at line 92 of file O3NameSolver.h.

typeName__

template<typename GUM_SCALAR >

NameMap gum::prm::o3prm::O3NameSolver< GUM_SCALAR >::typeName__

private

Definition at line 90 of file O3NameSolver.h.

---

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

• agrum/PRM/o3prm/O3NameSolver.h
• agrum/PRM/o3prm/O3NameSolver_tpl.h