Represents a O3PRMR context. More...

#include <O3prmrInterpreter.h>

Collaboration diagram for gum::prm::o3prmr::O3prmrInterpreter:

Public Member Functions
	O3prmrInterpreter ()
	This constructor create an empty context.
	~O3prmrInterpreter ()
	Destructor. Delete current context.
bool	interpretFile (std::string_view filename)
	Interpret the file or the command line.
bool	interpretLine (std::string_view line)
const gum::prm::PRM< double > *	prm () const
	Retrieve prm object.
const gum::prm::PRMInference< double > *	inference () const
	Retrieve inference motor object.
const std::vector< QueryResult > &	results () const
	Return a vector of QueryResults. Each QueryResults is a struct with query command, time and values, a vector of struct SingleResult, with pair label/value.
ErrorsContainer	errorsContainer () const
	Return container with all errors.
O3prmrContext< double > *	getContext () const
	Getter and setter for the context.
void	setContext (O3prmrContext< double > *context)
	Setter for the context.
std::vector< std::string >	getPaths () const
	Root paths to search from there packages. Default are working dir, request file dir if any and one is calculate from package if any.
void	addPath (std::string path)
	Root paths to search from there packages. Default are './' and one is calculate from request package if any.
void	clearPaths ()
	Root paths to search from there packages. Default are './' and one is calculate from request package if any.
bool	isInSyntaxMode () const
	syntax mode don't process anything, just check syntax. Default is false.
void	setSyntaxMode (bool f)
	syntax mode don't process anything, just check syntax.
bool	isVerboseMode () const
	verbose mode show more details on the program execution. Default is false.
void	setVerboseMode (bool f)
	verbose mode show more details on the program execution.
Size	count () const
	En cas d'échec, l'API de gestion d'erreurs est présente.
Size	errors () const
Size	warnings () const
ParseError	error (Idx i) const
	throw a string error if i >= count
void	showElegantErrors (std::ostream &o=std::cerr) const
	send on std::cerr the list of errors
void	showElegantErrorsAndWarnings (std::ostream &o=std::cerr) const
	send on std::cerr the list of errors or warnings
void	showErrorCounts (std::ostream &o=std::cerr) const
	send on std::cerr the number of errors and the number of warnings

Private Member Functions
bool	checkSemantic (O3prmrContext< double > *context)
	Check semantic validity of context.
bool	checkSetEngine (SetEngineCommand *command)
bool	checkSetGndEngine (SetGndEngineCommand *command)
bool	checkObserve (ObserveCommand< double > *command)
bool	checkUnobserve (UnobserveCommand< double > *command)
bool	checkQuery (QueryCommand< double > *command)
bool	interpret (O3prmrContext< double > *c)
	Crée le prm correspondant au contexte courant.
bool	import (O3prmrContext< double > *context, std::string import)
bool	observe (const ObserveCommand< double > *command)
bool	unobserve (const UnobserveCommand< double > *command)
void	query (const QueryCommand< double > *command)
void	setEngine (const SetEngineCommand *command)
void	setGndEngine (const SetGndEngineCommand *command)
std::string	findSystemName (std::string &s)
std::string	findInstanceName (std::string &s, const gum::prm::PRMSystem< double > &sys)
std::string	findAttributeName (std::string_view s, const gum::prm::PRMInstance< double > &instance)
const PRMSystem< double > &	system (std::string &ident)
void	generateInfEngine (const gum::prm::PRMSystem< double > &sys)
void	addError (std::string msg)
void	addWarning (std::string msg)
std::string	_readFile_ (std::string_view file)

Private Attributes
O3prmrContext< double > *	m_context
gum::prm::o3prm::O3prmReader< double > *	m_reader
std::vector< std::string >	m_paths
gum::BayesNet< double > *	m_bn
gum::prm::PRMInference< double > *	m_inf
HashTable< const PRMSystem< double > , PRMInference< double > >	m_inf_map
std::string	m_engine
std::string	m_bn_engine
std::vector< QueryResult >	m_results
gum::ErrorsContainer	m_errors
bool	m_syntax_flag
bool	m_verbose
std::ostream &	m_log
int	m_current_line

Detailed Description

Represents a O3PRMR context.

O3prmr use the <double> version of the O3PRM templatized ecosystem

Definition at line 87 of file O3prmrInterpreter.h.

Constructor & Destructor Documentation

◆ O3prmrInterpreter()

gum::prm::o3prmr::O3prmrInterpreter::O3prmrInterpreter ( )

This constructor create an empty context.

Definition at line 76 of file O3prmrInterpreter.cpp.

                                           :
          m_context(new O3prmrContext< double >()), m_reader(new o3prm::O3prmReader< double >()),
          m_bn(0), m_inf(0), m_syntax_flag(false), m_verbose(false), m_log(std::cout),
          m_current_line(-1) {}

References m_bn, m_context, m_current_line, m_inf, m_log, m_reader, m_syntax_flag, and m_verbose.

◆ ~O3prmrInterpreter()

gum::prm::o3prmr::O3prmrInterpreter::~O3prmrInterpreter ( )

Destructor. Delete current context.

Definition at line 82 of file O3prmrInterpreter.cpp.

                                            {
        delete m_context;
        if (m_bn) { delete m_bn; }
        for (auto p: m_inf_map) {
          delete p.second;
        }
        delete m_reader->prm();
        delete m_reader;
      }

References m_bn, m_context, m_inf_map, m_reader, and gum::prm::o3prm::O3prmReader< GUM_SCALAR >::prm().

Here is the call graph for this function:

Member Function Documentation

◆ _readFile_()

std::string gum::prm::o3prmr::O3prmrInterpreter::_readFile_ ( std::string_view file )

private

Definition at line 199 of file O3prmrInterpreter.cpp.

                                                                 {
        // read entire file into string
        std::ifstream istream(std::string(file), std::ifstream::binary);
        if (istream) {
          // get length of file:
          istream.seekg(0, istream.end);
          int length = int(istream.tellg());
          istream.seekg(0, istream.beg);
 
          std::string str;
          str.resize(length, ' ');   // reserve space
          char* begin = &*str.begin();
 
          istream.read(begin, length);
          istream.close();
 
          return str;
        }
        GUM_ERROR(OperationNotAllowed, "Could not open file")
      }

References GUM_ERROR.

Referenced by interpretFile().

Here is the caller graph for this function:

◆ addError()

void gum::prm::o3prmr::O3prmrInterpreter::addError ( std::string msg )

private

Definition at line 934 of file O3prmrInterpreter.cpp.

                                                    {
        m_errors.addError(msg, m_context->filename(), m_current_line, 0);
 
        if (m_verbose) m_log << m_errors.last().toString() << std::endl;
      }

References gum::ErrorsContainer::addError(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::filename(), gum::ErrorsContainer::last(), m_context, m_current_line, m_errors, m_log, m_verbose, and gum::ParseError::toString().

Referenced by checkObserve(), checkQuery(), checkSemantic(), checkUnobserve(), import(), and interpret().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addPath()

void gum::prm::o3prmr::O3prmrInterpreter::addPath ( std::string path )

Root paths to search from there packages. Default are './' and one is calculate from request package if any.

Definition at line 112 of file O3prmrInterpreter.cpp.

                                                    {
        if (path.length() && path.back() != '/') { path = path + '/'; }
 
        std::filesystem::directory_entry dir(path);
        if (dir.exists()) {
          m_paths.push_back(path);
        } else {
          GUM_ERROR(NotFound, "not a directory")
        }
      }

References GUM_ERROR, and m_paths.

◆ addWarning()

void gum::prm::o3prmr::O3prmrInterpreter::addWarning ( std::string msg )

private

Definition at line 941 of file O3prmrInterpreter.cpp.

                                                      {
        m_errors.addWarning(msg, m_context->filename(), m_current_line, 0);
 
        if (m_verbose) m_log << m_errors.last().toString() << std::endl;
      }

References gum::ErrorsContainer::addWarning(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::filename(), gum::ErrorsContainer::last(), m_context, m_current_line, m_errors, m_log, m_verbose, and gum::ParseError::toString().

Referenced by generateInfEngine(), observe(), and unobserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkObserve()

bool gum::prm::o3prmr::O3prmrInterpreter::checkObserve ( ObserveCommand< double > * command )

private

Definition at line 433 of file O3prmrInterpreter.cpp.

                                                                            {
        try {
          std::string       left_val  = command->leftValue;
          const std::string right_val = command->rightValue;
 
          // Contruct the pair (instance,attribut)
          const PRMSystem< double >&    sys      = system(left_val);
          const PRMInstance< double >&  instance = sys.get(findInstanceName(left_val, sys));
          const PRMAttribute< double >& attr = instance.get(findAttributeName(left_val, instance));
          typename PRMInference< double >::Chain chain = std::make_pair(&instance, &attr);
 
          command->system = &sys;
          command->chain  = std::make_pair(&instance, &attr);
 
          // Check label exists for this type.
          // Tensor<double> e;
          command->potentiel.add(chain.second->type().variable());
          Instantiation i(command->potentiel);
          bool          found = false;
 
          for (i.setFirst(); !i.end(); i.inc()) {
            if (chain.second->type().variable().label(i.val(chain.second->type().variable()))
                == right_val) {
              command->potentiel.set(i, (double)1.0);
              found = true;
            } else {
              command->potentiel.set(i, (double)0.0);
            }
          }
 
          if (!found) addError(right_val + " is not a label of " + left_val);
 
          // else command->potentiel = e;
 
          return found;
        } catch (Exception& err) { addError(err.errorContent()); } catch (std::string& err) {
          addError(err);
        }
 
        return false;
      }

References addError(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::chain, gum::Instantiation::end(), gum::Exception::errorContent(), findAttributeName(), findInstanceName(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMSystem< GUM_SCALAR >::get(), gum::Instantiation::inc(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::leftValue, gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::potentiel, gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::rightValue, gum::Instantiation::setFirst(), system(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::system, and gum::Instantiation::val().

Referenced by checkSemantic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkQuery()

bool gum::prm::o3prmr::O3prmrInterpreter::checkQuery ( QueryCommand< double > * command )

private

Definition at line 497 of file O3prmrInterpreter.cpp.

                                                                        {
        try {
          std::string name = command->value;
 
          // Contruct the pair (instance,attribut)
          const PRMSystem< double >&    sys      = system(name);
          const PRMInstance< double >&  instance = sys.get(findInstanceName(name, sys));
          const PRMAttribute< double >& attr     = instance.get(findAttributeName(name, instance));
          // PRMInference<double>::Chain chain = std::make_pair(&instance,
          // &attr);
 
          command->system = &sys;
          command->chain  = std::make_pair(&instance, &attr);
 
          return true;
        } catch (Exception& err) { addError(err.errorContent()); } catch (std::string& err) {
          addError(err);
        }
 
        return false;
      }

References addError(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::chain, gum::Exception::errorContent(), findAttributeName(), findInstanceName(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMSystem< GUM_SCALAR >::get(), system(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::system, and gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::value.

Referenced by checkSemantic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkSemantic()

bool gum::prm::o3prmr::O3prmrInterpreter::checkSemantic ( O3prmrContext< double > * context )

private

Check semantic validity of context.

Import first all import, and check that systems, instances, attributes and labels exists. While checking, prepare data structures for interpretation. Return true if all is right, false otherwise.

Note : Stop checking at first error unless syntax mode is activated.

Definition at line 317 of file O3prmrInterpreter.cpp.

                                                                            {
        // Don't parse if any syntax errors.
        if (errors() > 0) return false;
 
        // On importe tous les systèmes.
        for (const auto command: context->imports()) {
          m_current_line = command->line;
          // if import doen't succed stop here unless syntax mode is activated.
          bool succeed = import(context, command->value);
 
          if (!succeed && !isInSyntaxMode()) return false;
 
          // En cas de succès, on met à jour le contexte global
          if (succeed) m_context->addImport(*command);
        }
 
        if (m_verbose)
          m_log << "## Check semantic for " << context->sessions().size() << " sessions"
                << std::endl;
 
        // On vérifie chaque session
        for (const auto session: context->sessions()) {
          std::string              sessionName = session->name();
          O3prmrSession< double >* new_session = new O3prmrSession< double >(sessionName);
 
          if (m_verbose)
            m_log << "## Start session '" << sessionName << "'..." << std::endl << std::endl;
 
          for (const auto command: session->commands()) {
            if (m_verbose)
              m_log << "# * Going to check command : " << command->toString() << std::endl;
 
            // Update the current line (for warnings and errors)
            m_current_line = command->line;
 
            // We check it.
            bool result = true;
 
            try {
              switch (command->type()) {
                case O3prmrCommand::RequestType::SetEngine :
                  result = checkSetEngine((SetEngineCommand*)command);
                  break;
 
                case O3prmrCommand::RequestType::SetGndEngine :
                  result = checkSetGndEngine((SetGndEngineCommand*)command);
                  break;
 
                case O3prmrCommand::RequestType::Observe :
                  result = checkObserve((ObserveCommand< double >*)command);
                  break;
 
                case O3prmrCommand::RequestType::Unobserve :
                  result = checkUnobserve((UnobserveCommand< double >*)command);
                  break;
 
                case O3prmrCommand::RequestType::Query :
                  result = checkQuery((QueryCommand< double >*)command);
                  break;
 
                default :
                  addError("Error : Unknow command : " + command->toString()
                           + "\n -> Command not processed.");
                  result = false;
              }
            } catch (Exception& err) {
              result = false;
              addError(err.errorContent());
            } catch (std::string& err) {
              result = false;
              addError(err);
            }
 
            // If there was a problem, skip the rest of this session,
            // unless syntax mode is activated.
            if (!result && !isInSyntaxMode()) {
              if (m_verbose) m_log << "Errors : skip the rest of this session." << std::endl;
 
              break;
            }
 
            // On l'ajoute au contexte globale
            if (result) new_session->addCommand((const O3prmrCommand*)command);
          }
 
          // Ajoute la session au contexte global,
          // ou à la dernière session.
          if (sessionName == "default" && m_context->sessions().size() > 0)
            *(m_context->sessions().back()) += *new_session;
          else m_context->addSession(*new_session);
 
          if (m_verbose)
            m_log << std::endl
                  << "## Session '" << sessionName << "' finished." << std::endl
                  << std::endl
                  << std::endl;
 
          // todo : check memory leak
          // delete new_session; ??
        }
 
        if (isVerboseMode() && errors() != 0) m_errors.elegantErrorsAndWarnings(m_log);
 
        return errors() == 0;
      }

Referenced by interpretFile(), and interpretLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkSetEngine()

bool gum::prm::o3prmr::O3prmrInterpreter::checkSetEngine ( SetEngineCommand * command )

private

Definition at line 423 of file O3prmrInterpreter.cpp.

                                                                      {
        m_engine = command->value;
        return m_engine == "SVED" || m_engine == "GRD" || m_engine == "SVE";
      }

References m_engine, and gum::prm::o3prmr::SetEngineCommand::value.

Referenced by checkSemantic().

Here is the caller graph for this function:

◆ checkSetGndEngine()

bool gum::prm::o3prmr::O3prmrInterpreter::checkSetGndEngine ( SetGndEngineCommand * command )

private

Definition at line 428 of file O3prmrInterpreter.cpp.

                                                                            {
        m_bn_engine = command->value;
        return m_bn_engine == "VE" || m_bn_engine == "VEBB" || m_bn_engine == "lazy";
      }

References m_bn_engine, and gum::prm::o3prmr::SetGndEngineCommand::value.

Referenced by checkSemantic().

Here is the caller graph for this function:

◆ checkUnobserve()

bool gum::prm::o3prmr::O3prmrInterpreter::checkUnobserve ( UnobserveCommand< double > * command )

private

Definition at line 475 of file O3prmrInterpreter.cpp.

                                                                                {
        try {
          std::string name = command->value;
 
          // Contruct the pair (instance,attribut)
          const PRMSystem< double >&    sys      = system(name);
          const PRMInstance< double >&  instance = sys.get(findInstanceName(name, sys));
          const PRMAttribute< double >& attr     = instance.get(findAttributeName(name, instance));
          // PRMInference<double>::Chain chain = std::make_pair(&instance,
          // &attr);
 
          command->system = &sys;
          command->chain  = std::make_pair(&instance, &attr);
 
          return true;
        } catch (Exception& err) { addError(err.errorContent()); } catch (std::string& err) {
          addError(err);
        }
 
        return false;
      }

References addError(), gum::prm::o3prmr::UnobserveCommand< GUM_SCALAR >::chain, gum::Exception::errorContent(), findAttributeName(), findInstanceName(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMSystem< GUM_SCALAR >::get(), system(), gum::prm::o3prmr::UnobserveCommand< GUM_SCALAR >::system, and gum::prm::o3prmr::UnobserveCommand< GUM_SCALAR >::value.

Referenced by checkSemantic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearPaths()

void gum::prm::o3prmr::O3prmrInterpreter::clearPaths ( )

Root paths to search from there packages. Default are './' and one is calculate from request package if any.

Definition at line 125 of file O3prmrInterpreter.cpp.

125{ m_paths.clear(); }

References m_paths.

◆ count()

Size gum::prm::o3prmr::O3prmrInterpreter::count ( ) const

En cas d'échec, l'API de gestion d'erreurs est présente.

of errors + warnings

Definition at line 897 of file O3prmrInterpreter.cpp.

897{ return m_errors.count(); }

gum::ErrorsContainer::count

Size count() const

Returns the number of errors and warnings.

Definition errorsContainer_inl.h:103

References gum::ErrorsContainer::count(), and m_errors.

Referenced by error(), and import().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error()

ParseError gum::prm::o3prmr::O3prmrInterpreter::error ( Idx i ) const

throw a string error if i >= count

Definition at line 906 of file O3prmrInterpreter.cpp.

                                                     {
        if (i >= count()) throw "Index out of bound.";
 
        return m_errors.error(i);
      }

References count(), gum::ErrorsContainer::error(), and m_errors.

Here is the call graph for this function:

◆ errors()

Size gum::prm::o3prmr::O3prmrInterpreter::errors ( ) const

of errors

Definition at line 900 of file O3prmrInterpreter.cpp.

900{ return m_errors.error_count; }

gum::ErrorsContainer::error_count

Size error_count

Number of errors detected.

Definition errorsContainer.h:186

References gum::ErrorsContainer::error_count, and m_errors.

Referenced by checkSemantic(), import(), interpret(), interpretFile(), and interpretLine().

Here is the caller graph for this function:

◆ errorsContainer()

ErrorsContainer gum::prm::o3prmr::O3prmrInterpreter::errorsContainer ( ) const

Return container with all errors.

Definition at line 913 of file O3prmrInterpreter.cpp.

913{ return m_errors; }

References m_errors.

◆ findAttributeName()

std::string gum::prm::o3prmr::O3prmrInterpreter::findAttributeName	(	std::string_view	s,
		const gum::prm::PRMInstance< double > &	instance )

private

Definition at line 709 of file O3prmrInterpreter.cpp.

                                                                                              {
        if (!instance.exists(s))
          throw "'" + std::string{s} + "' is not an attribute of instance '" + instance.name()
              + "'.";
 
        return std::string{s};
      }

References gum::prm::PRMInstance< GUM_SCALAR >::exists(), and gum::prm::PRMObject::name().

Referenced by checkObserve(), checkQuery(), and checkUnobserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findInstanceName()

std::string gum::prm::o3prmr::O3prmrInterpreter::findInstanceName	(	std::string &	s,
		const gum::prm::PRMSystem< double > &	sys )

private

Definition at line 696 of file O3prmrInterpreter.cpp.

                                                                                      {
        // We have found system before, so 's' has been stripped.
        size_t      dot  = s.find_first_of('.');
        std::string name = s.substr(0, dot);
 
        if (!sys.exists(name))
          throw "'" + name + "' is not an instance of system '" + sys.name() + "'.";
 
        s = s.substr(dot + 1);
        return name;
      }

References gum::prm::PRMSystem< GUM_SCALAR >::exists(), and gum::prm::PRMObject::name().

Referenced by checkObserve(), checkQuery(), and checkUnobserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findSystemName()

std::string gum::prm::o3prmr::O3prmrInterpreter::findSystemName ( std::string & s )

private

Definition at line 668 of file O3prmrInterpreter.cpp.

                                                              {
        size_t      dot  = s.find_first_of('.');
        std::string name = s.substr(0, dot);
 
        // We look first for real system, next for alias.
        if (prm()->isSystem(name)) {
          s = s.substr(dot + 1);
          return name;
        }
 
        if (!m_context->aliasToImport(name).empty()) {
          s = s.substr(dot + 1);
          return m_context->aliasToImport(name);
        }
 
        while (dot != std::string::npos) {
          if (prm()->isSystem(name)) {
            s = s.substr(dot + 1);
            return name;
          }
 
          dot  = s.find('.', dot + 1);
          name = s.substr(0, dot);
        }
 
        throw "could not find any system in '" + s + "'.";
      }

References gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::aliasToImport(), m_context, and prm().

Referenced by system().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generateInfEngine()

void gum::prm::o3prmr::O3prmrInterpreter::generateInfEngine ( const gum::prm::PRMSystem< double > & sys )

private

Definition at line 855 of file O3prmrInterpreter.cpp.

                                                                              {
        if (m_verbose) m_log << "# Building the inference engine... " << std::flush;
 
        //
        if (m_engine == "SVED") {
          m_inf = new SVED< double >(*(prm()), sys);
 
          //
        } else if (m_engine == "SVE") {
          m_inf = new SVE< double >(*(prm()), sys);
        } else {
          if (m_engine != "GRD") {
            addWarning("unkown engine '" + m_engine + "', use GRD insteed.");
          }
 
          MarginalTargetedInference< double >* bn_inf = nullptr;
          if (m_bn) { delete m_bn; }
          m_bn = new BayesNet< double >();
          BayesNetFactory< double > bn_factory(m_bn);
 
          if (m_verbose) m_log << "(Grounding the network... " << std::flush;
 
          sys.groundedBN(bn_factory);
 
          if (m_verbose) m_log << "Finished)" << std::flush;
 
          // bn_inf = new LazyPropagation<double>( *m_bn );
          bn_inf = new VariableElimination< double >(m_bn);
 
          auto grd_inf = new GroundedInference< double >(*(prm()), sys);
          grd_inf->setBNInference(bn_inf);
          m_inf = grd_inf;
        }
 
        m_inf_map.insert(&sys, m_inf);
        if (m_verbose) m_log << "Finished." << std::endl;
      }

References gum::prm::GroundedInference< GUM_SCALAR >::GroundedInference(), gum::prm::SVE< GUM_SCALAR >::SVE(), gum::prm::SVED< GUM_SCALAR >::SVED(), addWarning(), gum::BayesNet< double >, gum::BayesNetFactory< double >, gum::prm::PRMSystem< GUM_SCALAR >::groundedBN(), m_bn, m_engine, m_inf, m_inf_map, m_log, m_verbose, prm(), and gum::VariableElimination< double >.

Referenced by observe(), and query().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getContext()

O3prmrContext< double > * gum::prm::o3prmr::O3prmrInterpreter::getContext ( ) const

Getter and setter for the context.

Getter for the context.

Definition at line 96 of file O3prmrInterpreter.cpp.

96{ return m_context; }

References m_context.

◆ getPaths()

std::vector< std::string > gum::prm::o3prmr::O3prmrInterpreter::getPaths ( ) const

Root paths to search from there packages. Default are working dir, request file dir if any and one is calculate from package if any.

Root paths to search from there packages. Default are './' and one is calculate from request package if any.

Definition at line 108 of file O3prmrInterpreter.cpp.

108{ return m_paths; }

References m_paths.

◆ import()

bool gum::prm::o3prmr::O3prmrInterpreter::import	(	O3prmrContext< double > *	context,
		std::string	import )

private

Definition at line 522 of file O3prmrInterpreter.cpp.

                                                                                            {
        try {
          if (m_verbose) { m_log << "# Loading system '" << import_name << "' => '" << std::flush; }
 
          std::string import_package = import_name;
 
          std::replace(import_name.begin(), import_name.end(), '.', '/');
          import_name += ".o3prm";
 
          if (m_verbose) { m_log << import_name << "' ... " << std::endl << std::flush; }
 
          std::ifstream file_test;
          bool          found = false;
          std::string   import_abs_filename;
 
          // Search in o3prmr file dir.
          std::string o3prmrFilename = context->filename();
 
          if (!o3prmrFilename.empty()) {
            if (auto index = o3prmrFilename.find_last_of('/'); index != std::string::npos) {
              std::string dir     = o3prmrFilename.substr(0, index + 1);
              import_abs_filename = dir + import_name;
 
              if (m_verbose) {
                m_log << "# Search from filedir '" << import_abs_filename << "' ... " << std::flush;
              }
 
              file_test.open(import_abs_filename.c_str());
 
              if (file_test.is_open()) {
                if (m_verbose) { m_log << "found !" << std::endl << std::flush; }
 
                file_test.close();
                found = true;
              } else if (m_verbose) {
                m_log << "not found." << std::endl << std::flush;
              }
            }
          }
 
          // Deduce root path from package name.
          std::string package = context->package();
 
          if (!found && !package.empty()) {
            std::string root;
 
            // if filename is not empty, start from it.
            std::string filename = context->filename();
 
            if (!filename.empty()) {
              if (auto size = filename.find_last_of('/'); size != std::string::npos) {
                root += filename.substr(0, size + 1);   // take with the '/'
              }
            }
 
            //
            root += "../";
            int count = (int)std::count(package.begin(), package.end(), '.');
 
            for (int i = 0; i < count; i++)
              root += "../";
 
            import_abs_filename = std::filesystem::absolute(std::filesystem::path(root)
                                                            / std::filesystem::path(import_name))
                                      .string();
 
            if (m_verbose) {
              m_log << "# Search from package '" << package << "' => '" << import_abs_filename
                    << "' ... " << std::flush;
            }
 
            file_test.open(import_abs_filename.c_str());
 
            if (file_test.is_open()) {
              if (m_verbose) { m_log << "found !" << std::endl << std::flush; }
 
              file_test.close();
              found = true;
            } else if (m_verbose) {
              m_log << "not found." << std::endl << std::flush;
            }
          }
 
          // Search import in all paths.
          for (const auto& path: m_paths) {
            import_abs_filename = path + import_name;
 
            if (m_verbose) {
              m_log << "# Search from classpath '" << import_abs_filename << "' ... " << std::flush;
            }
 
            file_test.open(import_abs_filename.c_str());
 
            if (file_test.is_open()) {
              if (m_verbose) { m_log << " found !" << std::endl << std::flush; }
 
              file_test.close();
              found = true;
              break;
            } else if (m_verbose) {
              m_log << " not found." << std::endl << std::flush;
            }
          }
 
          if (!found) {
            if (m_verbose) { m_log << "Finished with errors." << std::endl; }
 
            addError("import not found.");
            return false;
          }
 
          // May throw std::IOError if file does't exist
          Size previousO3prmError  = m_reader->errors();
          Size previousO3prmrError = errors();
 
          try {
            m_reader->readFile(import_abs_filename, import_package);
 
            // Show errors and warning
            if (m_verbose
                && (m_reader->errors() > (unsigned int)previousO3prmError
                    || errors() > previousO3prmrError)) {
              m_log << "Finished with errors." << std::endl;
            } else if (m_verbose) {
              m_log << "Finished." << std::endl;
            }
          } catch (const IOError& err) {
            if (m_verbose) { m_log << "Finished with errors." << std::endl; }
 
            addError(err.errorContent());
          }
 
          // Add o3prm errors and warnings to o3prmr errors
          for (; previousO3prmError < m_reader->errorsContainer().count(); previousO3prmError++) {
            m_errors.add(m_reader->errorsContainer().error(previousO3prmError));
          }
 
          return errors() == previousO3prmrError;
        } catch (const Exception& err) {
          if (m_verbose) { m_log << "Finished with exceptions." << std::endl; }
 
          addError(err.errorContent());
          return false;
        }
      }

References addError(), count(), gum::Exception::errorContent(), errors(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::filename(), m_errors, m_log, m_paths, m_reader, and m_verbose.

Here is the call graph for this function:

◆ inference()

const PRMInference< double > * gum::prm::o3prmr::O3prmrInterpreter::inference ( ) const

Retrieve inference motor object.

Definition at line 143 of file O3prmrInterpreter.cpp.

143{ return m_inf; }

References m_inf.

◆ interpret()

bool gum::prm::o3prmr::O3prmrInterpreter::interpret ( O3prmrContext< double > * c )

private

Crée le prm correspondant au contexte courant.

Renvoie true en cas de succès, ou false en cas échéant d'échec de l'interprétation du contexte (import introuvable ou non défini, etc).

Definition at line 246 of file O3prmrInterpreter.cpp.

                                                                  {
        if (isVerboseMode()) m_log << "## Start interpretation." << std::endl << std::flush;
 
        // Don't parse if any syntax errors.
        if (errors() > 0) return false;
 
        // For each session
        std::vector< O3prmrSession< double >* > sessions = c->sessions();
 
        for (const auto session: sessions)
          for (auto command: session->commands()) {
            // We process it.
            bool result = true;
 
            try {
              switch (command->type()) {
                case O3prmrCommand::RequestType::Observe :
                  result = observe((ObserveCommand< double >*)command);
                  break;
 
                case O3prmrCommand::RequestType::Unobserve :
                  result = unobserve((UnobserveCommand< double >*)command);
                  break;
 
                case O3prmrCommand::RequestType::SetEngine :
                  setEngine((SetEngineCommand*)command);
                  break;
 
                case O3prmrCommand::RequestType::SetGndEngine :
                  setGndEngine((SetGndEngineCommand*)command);
                  break;
 
                case O3prmrCommand::RequestType::Query :
                  query((QueryCommand< double >*)command);
                  break;
              }
            } catch (Exception& err) {
              result = false;
              addError(err.errorContent());
            } catch (std::string& err) {
              result = false;
              addError(err);
            }
 
            // If there was a problem, skip the rest of this session,
            // unless syntax mode is activated.
            if (!result) {
              if (m_verbose) m_log << "Errors : skip the rest of this session." << std::endl;
 
              break;
            }
          }
 
        if (isVerboseMode()) m_log << "## End interpretation." << std::endl << std::flush;
 
        return errors() == 0;
      }

References addError(), gum::Exception::errorContent(), errors(), isVerboseMode(), m_log, m_verbose, gum::prm::o3prmr::O3prmrCommand::Observe, observe(), gum::prm::o3prmr::O3prmrCommand::Query, query(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::sessions(), gum::prm::o3prmr::O3prmrCommand::SetEngine, setEngine(), gum::prm::o3prmr::O3prmrCommand::SetGndEngine, setGndEngine(), gum::prm::o3prmr::O3prmrCommand::Unobserve, and unobserve().

Referenced by interpretFile(), and interpretLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ interpretFile()

bool gum::prm::o3prmr::O3prmrInterpreter::interpretFile ( std::string_view filename )

Interpret the file or the command line.

Parse the file or the command line.

If syntax mode is activated, check only syntax and semantic. If errors occured, return false. Errors messages can be retrieve be errorsContainer() methods. If any errors occured, return true. Requests results can be retrieve be results() methods.

If errors occured, return false. Errors messages can be retrieve be getErrorsContainer() methods. If any errors occured, return true. Requests results can be retrieve be results() methods.

Definition at line 157 of file O3prmrInterpreter.cpp.

                                                                   {
        m_results.clear();
 
        try {
          std::string file_content = _readFile_(filename);
 
          delete m_context;
          m_context = new O3prmrContext< double >(std::string(filename));
          O3prmrContext< double > c{std::string(filename)};
 
          // On vérifie la syntaxe
          unsigned char* buffer = new unsigned char[file_content.length() + 1];
          strcpy((char*)buffer, file_content.c_str());
          Scanner s(buffer, int(file_content.length() + 1));
          Parser  p(&s);
          p.setO3prmrContext(&c);
          p.Parse();
 
          m_errors = p.errors();
 
          if (errors() > 0) { return false; }
 
          // Set paths to search from.
          delete m_reader->prm();
          delete m_reader;
          m_reader = new o3prm::O3prmReader< double >();
 
          for (size_t i = 0; i < m_paths.size(); i++) {
            m_reader->addClassPath(m_paths[i]);
          }
 
          // On vérifie la sémantique.
          if (!checkSemantic(&c)) { return false; }
 
          if (isInSyntaxMode()) {
            return true;
          } else {
            return interpret(&c);
          }
        } catch (gum::Exception&) { return false; }
      }

References _readFile_(), gum::prm::o3prm::O3prmReader< GUM_SCALAR >::addClassPath(), checkSemantic(), errors(), interpret(), isInSyntaxMode(), m_context, m_errors, m_paths, m_reader, m_results, and gum::prm::o3prm::O3prmReader< GUM_SCALAR >::prm().

Here is the call graph for this function:

◆ interpretLine()

bool gum::prm::o3prmr::O3prmrInterpreter::interpretLine ( std::string_view line )

Definition at line 220 of file O3prmrInterpreter.cpp.

                                                               {
        m_results.clear();
 
        // On vérifie la syntaxe
        O3prmrContext< double > c;
        Scanner                 s((unsigned char*)line.data(), (int)line.length());
        Parser                  p(&s);
        p.setO3prmrContext(&c);
        p.Parse();
        m_errors = p.errors();
 
        if (errors() > 0) return false;
 
        // On vérifie la sémantique.
        if (!checkSemantic(&c)) return false;
 
        if (isInSyntaxMode()) return true;
        else return interpret(&c);
      }

References checkSemantic(), errors(), interpret(), isInSyntaxMode(), m_errors, and m_results.

Here is the call graph for this function:

◆ isInSyntaxMode()

bool gum::prm::o3prmr::O3prmrInterpreter::isInSyntaxMode ( ) const

syntax mode don't process anything, just check syntax. Default is false.

syntax mode don't process anything, just check syntax.

Definition at line 128 of file O3prmrInterpreter.cpp.

128{ return m_syntax_flag; }

References m_syntax_flag.

Referenced by checkSemantic(), interpretFile(), and interpretLine().

Here is the caller graph for this function:

◆ isVerboseMode()

bool gum::prm::o3prmr::O3prmrInterpreter::isVerboseMode ( ) const

verbose mode show more details on the program execution. Default is false.

verbose mode show more details on the program execution.

Definition at line 134 of file O3prmrInterpreter.cpp.

134{ return m_verbose; }

References m_verbose.

Referenced by checkSemantic(), and interpret().

Here is the caller graph for this function:

◆ observe()

bool gum::prm::o3prmr::O3prmrInterpreter::observe ( const ObserveCommand< double > * command )

private

Definition at line 733 of file O3prmrInterpreter.cpp.

                                                                                 {
        const typename PRMInference< double >::Chain& chain = command->chain;
 
        // Generate the inference engine if it doesn't exist.
        if (!m_inf) { generateInfEngine(*(command->system)); }
 
        // Prevent from something
        if (m_inf->hasEvidence(chain)) addWarning(command->leftValue + " is already observed");
 
        m_inf->addEvidence(chain, command->potentiel);
 
        if (m_verbose)
          m_log << "# Added evidence " << command->rightValue << " over attribute "
                << command->leftValue << std::endl;
 
        return true;
      } catch (OperationNotAllowed& ex) {
        addError("something went wrong when adding evidence " + command->rightValue + " over "
                 + command->leftValue + " : " + ex.errorContent());
        return false;
      } catch (const std::string& msg) {
        addError(msg);
        return false;
      }

References gum::prm::PRMInference< GUM_SCALAR >::addEvidence(), addWarning(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::chain, generateInfEngine(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::leftValue, m_inf, m_log, m_verbose, gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::potentiel, gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::rightValue, and gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::system.

Referenced by interpret().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prm()

const PRM< double > * gum::prm::o3prmr::O3prmrInterpreter::prm ( ) const

Retrieve prm object.

Definition at line 140 of file O3prmrInterpreter.cpp.

140{ return m_reader->prm(); }

References m_reader, and gum::prm::o3prm::O3prmReader< GUM_SCALAR >::prm().

Referenced by findSystemName(), generateInfEngine(), and system().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query()

void gum::prm::o3prmr::O3prmrInterpreter::query ( const QueryCommand< double > * command )

private

Definition at line 780 of file O3prmrInterpreter.cpp.

                                                                             {
        const std::string& query = command->value;
 
        if (m_inf_map.exists(command->system)) {
          m_inf = m_inf_map[command->system];
        } else {
          m_inf = nullptr;
        }
 
        // Create inference engine if it has not been already created.
        if (!m_inf) { generateInfEngine(*(command->system)); }
 
        // Inference
        if (m_verbose) {
          m_log << "# Starting inference over query: " << query << "... " << std::endl;
        }
 
        Timer timer;
        timer.reset();
 
        Tensor< double > m;
        m_inf->posterior(command->chain, m);
 
        // Compute spent time
        double t = timer.step();
 
        if (m_verbose) { m_log << "Finished." << std::endl; }
 
        if (m_verbose) { m_log << "# Time in seconds (accuracy ~0.001): " << t << std::endl; }
 
        // Show results
 
        if (m_verbose) { m_log << std::endl; }
 
        QueryResult result;
        result.command = query;
        result.time    = t;
 
        Instantiation                 j(m);
        const PRMAttribute< double >& attr = *(command->chain.second);
 
        for (j.setFirst(); !j.end(); j.inc()) {
          // auto label_value = j.val ( attr.type().variable() );
          auto        label_value = j.val(0);
          std::string label       = attr.type().variable().label(label_value);
          float       value       = float(m.get(j));
 
          SingleResult singleResult;
          singleResult.label = label;
          singleResult.p     = value;
 
          result.values.push_back(singleResult);
 
          if (m_verbose) { m_log << label << " : " << value << std::endl; }
        }
 
        m_results.push_back(result);
 
        if (m_verbose) { m_log << std::endl; }
      } catch (Exception& e) {
        GUM_SHOWERROR(e);
        throw "something went wrong while infering: " + e.errorContent();
      } catch (const std::string& msg) { addError(msg); }

References gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::chain, gum::prm::o3prmr::QueryResult::command, gum::Instantiation::end(), generateInfEngine(), gum::MultiDimDecorator< GUM_ELEMENT >::get(), gum::Instantiation::inc(), gum::DiscreteVariable::label(), gum::prm::o3prmr::SingleResult::label, m_inf, m_inf_map, m_log, m_results, m_verbose, gum::prm::o3prmr::SingleResult::p, gum::prm::PRMInference< GUM_SCALAR >::posterior(), query(), gum::Timer::reset(), gum::Instantiation::setFirst(), gum::Timer::step(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::system, gum::Tensor< double >, gum::prm::o3prmr::QueryResult::time, gum::prm::PRMAttribute< GUM_SCALAR >::type(), gum::Instantiation::val(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::value, gum::prm::o3prmr::QueryResult::values, and gum::prm::PRMType::variable().

Referenced by interpret(), and query().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ results()

const std::vector< QueryResult > & gum::prm::o3prmr::O3prmrInterpreter::results ( ) const

Return a vector of QueryResults. Each QueryResults is a struct with query command, time and values, a vector of struct SingleResult, with pair label/value.

Return a std::vector of QueryResults. Each QueryResults is a struct with query command, time and values, a std::vector of struct SingleResult, with pair label/value.

Definition at line 148 of file O3prmrInterpreter.cpp.

148{ return m_results; }

References m_results.

◆ setContext()

void gum::prm::o3prmr::O3prmrInterpreter::setContext ( O3prmrContext< double > * context )

Setter for the context.

Definition at line 99 of file O3prmrInterpreter.cpp.

                                                                         {
        delete m_context;
 
        if (context == 0) m_context = new O3prmrContext< double >();
        else m_context = context;
      }

References m_context.

◆ setEngine()

void gum::prm::o3prmr::O3prmrInterpreter::setEngine ( const SetEngineCommand * command )

private

Definition at line 845 of file O3prmrInterpreter.cpp.

                                                                       {
        m_engine = command->value;
      }

References m_engine, and gum::prm::o3prmr::SetEngineCommand::value.

Referenced by interpret().

Here is the caller graph for this function:

◆ setGndEngine()

void gum::prm::o3prmr::O3prmrInterpreter::setGndEngine ( const SetGndEngineCommand * command )

private

Definition at line 850 of file O3prmrInterpreter.cpp.

                                                                             {
        m_bn_engine = command->value;
      }

References m_bn_engine, and gum::prm::o3prmr::SetGndEngineCommand::value.

Referenced by interpret().

Here is the caller graph for this function:

◆ setSyntaxMode()

void gum::prm::o3prmr::O3prmrInterpreter::setSyntaxMode ( bool f )

syntax mode don't process anything, just check syntax.

Definition at line 131 of file O3prmrInterpreter.cpp.

131{ m_syntax_flag = f; }

References m_syntax_flag.

◆ setVerboseMode()

void gum::prm::o3prmr::O3prmrInterpreter::setVerboseMode ( bool f )

verbose mode show more details on the program execution.

Definition at line 137 of file O3prmrInterpreter.cpp.

137{ m_verbose = f; }

References m_verbose.

◆ showElegantErrors()

void gum::prm::o3prmr::O3prmrInterpreter::showElegantErrors ( std::ostream & o = std::cerr ) const

send on std::cerr the list of errors

Definition at line 916 of file O3prmrInterpreter.cpp.

                                                                   {
        m_errors.elegantErrors(o);
      }

References gum::ErrorsContainer::elegantErrors(), and m_errors.

Here is the call graph for this function:

◆ showElegantErrorsAndWarnings()

void gum::prm::o3prmr::O3prmrInterpreter::showElegantErrorsAndWarnings ( std::ostream & o = std::cerr ) const

send on std::cerr the list of errors or warnings

Definition at line 921 of file O3prmrInterpreter.cpp.

                                                                              {
        m_errors.elegantErrorsAndWarnings(o);
      }

References gum::ErrorsContainer::elegantErrorsAndWarnings(), and m_errors.

Here is the call graph for this function:

◆ showErrorCounts()

void gum::prm::o3prmr::O3prmrInterpreter::showErrorCounts ( std::ostream & o = std::cerr ) const

send on std::cerr the number of errors and the number of warnings

Definition at line 926 of file O3prmrInterpreter.cpp.

                                                                 {
        m_errors.syntheticResults(o);
      }

References m_errors, and gum::ErrorsContainer::syntheticResults().

Here is the call graph for this function:

◆ system()

const PRMSystem< double > & gum::prm::o3prmr::O3prmrInterpreter::system ( std::string & ident )

private

Definition at line 719 of file O3prmrInterpreter.cpp.

                                                                           {
        try {
          return prm()->getSystem(findSystemName(ident));
        } catch (const std::string&) {}
 
        if ((m_context->mainImport() != 0) && prm()->isSystem(m_context->mainImport()->value))
          return prm()->getSystem(m_context->mainImport()->value);
 
        throw "could not find any system or alias in '" + ident
            + "' and no default alias has been set.";
      }

References findSystemName(), m_context, gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::mainImport(), prm(), and gum::prm::o3prmr::ImportCommand::value.

Referenced by checkObserve(), checkQuery(), and checkUnobserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unobserve()

bool gum::prm::o3prmr::O3prmrInterpreter::unobserve ( const UnobserveCommand< double > * command )

private

Definition at line 760 of file O3prmrInterpreter.cpp.

                                                                                     {
        std::string                            name  = command->value;
        typename PRMInference< double >::Chain chain = command->chain;
 
        // Prevent from something
        if (!m_inf || !m_inf->hasEvidence(chain)) {
          addWarning(name + " was not observed");
        } else {
          m_inf->removeEvidence(chain);
 
          if (m_verbose) m_log << "# Removed evidence over attribute " << name << std::endl;
        }
 
        return true;
      } catch (const std::string& msg) {
        addError(msg);
        return false;
      }

References addWarning(), gum::prm::o3prmr::UnobserveCommand< GUM_SCALAR >::chain, gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), m_inf, m_log, m_verbose, gum::prm::PRMInference< GUM_SCALAR >::removeEvidence(), and gum::prm::o3prmr::UnobserveCommand< GUM_SCALAR >::value.

Referenced by interpret().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ warnings()

Size gum::prm::o3prmr::O3prmrInterpreter::warnings ( ) const

of warnings

Definition at line 903 of file O3prmrInterpreter.cpp.

903{ return m_errors.warning_count; }

gum::ErrorsContainer::warning_count

Size warning_count

Definition errorsContainer.h:189

References m_errors, and gum::ErrorsContainer::warning_count.

Member Data Documentation

◆ m_bn

gum::BayesNet< double >* gum::prm::o3prmr::O3prmrInterpreter::m_bn

private

Definition at line 186 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), ~O3prmrInterpreter(), and generateInfEngine().

◆ m_bn_engine

std::string gum::prm::o3prmr::O3prmrInterpreter::m_bn_engine

private

Definition at line 191 of file O3prmrInterpreter.h.

Referenced by checkSetGndEngine(), and setGndEngine().

◆ m_context

O3prmrContext< double >* gum::prm::o3prmr::O3prmrInterpreter::m_context

private

Definition at line 183 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), ~O3prmrInterpreter(), addError(), addWarning(), checkSemantic(), findSystemName(), getContext(), interpretFile(), setContext(), and system().

◆ m_current_line

int gum::prm::o3prmr::O3prmrInterpreter::m_current_line

private

Definition at line 197 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), addError(), addWarning(), and checkSemantic().

◆ m_engine

std::string gum::prm::o3prmr::O3prmrInterpreter::m_engine

private

Definition at line 190 of file O3prmrInterpreter.h.

Referenced by checkSetEngine(), generateInfEngine(), and setEngine().

◆ m_errors

gum::ErrorsContainer gum::prm::o3prmr::O3prmrInterpreter::m_errors

private

Definition at line 193 of file O3prmrInterpreter.h.

Referenced by addError(), addWarning(), checkSemantic(), count(), error(), errors(), errorsContainer(), import(), interpretFile(), interpretLine(), showElegantErrors(), showElegantErrorsAndWarnings(), showErrorCounts(), and warnings().

◆ m_inf

gum::prm::PRMInference< double >* gum::prm::o3prmr::O3prmrInterpreter::m_inf

private

Definition at line 188 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), generateInfEngine(), inference(), observe(), query(), and unobserve().

◆ m_inf_map

HashTable< const PRMSystem< double >*, PRMInference< double >* > gum::prm::o3prmr::O3prmrInterpreter::m_inf_map

private

Definition at line 189 of file O3prmrInterpreter.h.

Referenced by ~O3prmrInterpreter(), generateInfEngine(), and query().

◆ m_log

std::ostream& gum::prm::o3prmr::O3prmrInterpreter::m_log

private

Definition at line 196 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), addError(), addWarning(), checkSemantic(), generateInfEngine(), import(), interpret(), observe(), query(), and unobserve().

◆ m_paths

std::vector< std::string > gum::prm::o3prmr::O3prmrInterpreter::m_paths

private

Definition at line 185 of file O3prmrInterpreter.h.

Referenced by addPath(), clearPaths(), getPaths(), import(), and interpretFile().

◆ m_reader

gum::prm::o3prm::O3prmReader< double >* gum::prm::o3prmr::O3prmrInterpreter::m_reader

private

Definition at line 184 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), ~O3prmrInterpreter(), import(), interpretFile(), and prm().

◆ m_results

std::vector< QueryResult > gum::prm::o3prmr::O3prmrInterpreter::m_results

private

Definition at line 192 of file O3prmrInterpreter.h.

Referenced by interpretFile(), interpretLine(), query(), and results().

◆ m_syntax_flag

bool gum::prm::o3prmr::O3prmrInterpreter::m_syntax_flag

private

Definition at line 194 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), isInSyntaxMode(), and setSyntaxMode().

◆ m_verbose

bool gum::prm::o3prmr::O3prmrInterpreter::m_verbose

private

Definition at line 195 of file O3prmrInterpreter.h.

Referenced by O3prmrInterpreter(), addError(), addWarning(), checkSemantic(), generateInfEngine(), import(), interpret(), isVerboseMode(), observe(), query(), setVerboseMode(), and unobserve().

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

agrum/PRM/o3prmr/O3prmrInterpreter.h
agrum/PRM/o3prmr/O3prmrInterpreter.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ O3prmrInterpreter()

◆ ~O3prmrInterpreter()

Member Function Documentation

◆ _readFile_()

◆ addError()

◆ addPath()

◆ addWarning()

◆ checkObserve()

◆ checkQuery()

◆ checkSemantic()

◆ checkSetEngine()

◆ checkSetGndEngine()

◆ checkUnobserve()

◆ clearPaths()

◆ count()

of errors + warnings

◆ error()

◆ errors()

of errors

◆ errorsContainer()

◆ findAttributeName()

◆ findInstanceName()

◆ findSystemName()

◆ generateInfEngine()

◆ getContext()

◆ getPaths()

◆ import()

◆ inference()

◆ interpret()

◆ interpretFile()

◆ interpretLine()

◆ isInSyntaxMode()

◆ isVerboseMode()

◆ observe()

◆ prm()

◆ query()

◆ results()

◆ setContext()

◆ setEngine()

◆ setGndEngine()

◆ setSyntaxMode()

◆ setVerboseMode()

◆ showElegantErrors()

◆ showElegantErrorsAndWarnings()

◆ showErrorCounts()

◆ system()

◆ unobserve()

◆ warnings()

of warnings

Member Data Documentation

◆ m_bn

◆ m_bn_engine

◆ m_context

◆ m_current_line

◆ m_engine

◆ m_errors

◆ m_inf

◆ m_inf_map

◆ m_log

◆ m_paths

◆ m_reader

◆ m_results

◆ m_syntax_flag

◆ m_verbose