gum::prm::o3prmr::O3prmrInterpreter Class Reference

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

Detailed Description

Represents a O3PRMR context.

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

Definition at line 68 of file O3prmrInterpreter.h.

Constructor & Destructor Documentation

O3prmrInterpreter()

gum::prm::o3prmr::O3prmrInterpreter::O3prmrInterpreter

(

)

This constructor create an empty context.

Definition at line 51 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) {}

~O3prmrInterpreter()

gum::prm::o3prmr::O3prmrInterpreter::~O3prmrInterpreter

(

)

Destructor. Delete current context.

Definition at line 58 of file O3prmrInterpreter.cpp.

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

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

Here is the call graph for this function:

Member Function Documentation

__readFile()

std::string gum::prm::o3prmr::O3prmrInterpreter::__readFile ( const std::string &  file )

private

Definition at line 185 of file O3prmrInterpreter.cpp.

References GUM_ERROR.

Referenced by interpretFile().

                                                                   {
        // read entire file into string
        std::ifstream istream(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");
      }

Here is the caller graph for this function:

addError()

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

private

Definition at line 974 of file O3prmrInterpreter.cpp.

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(), interpret(), observe(), query(), and unobserve().

                                                    {
        m_errors.addError(msg, m_context->filename(), m_current_line, 0);

        if (m_verbose) m_log << m_errors.last().toString() << std::endl;
      }

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 94 of file O3prmrInterpreter.cpp.

References GUM_ERROR, gum::Directory::isDir(), and m_paths.

                                                    {
        if (path.length() && path.back() != '/') { path = path + '/'; }
        if (Directory::isDir(path)) {
          m_paths.push_back(path);
        } else {
          GUM_ERROR(NotFound, "not a directory");
        }
      }

Here is the call graph for this function:

addWarning()

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

private

Definition at line 981 of file O3prmrInterpreter.cpp.

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().

                                                      {
        m_errors.addWarning(msg, m_context->filename(), m_current_line, 0);

        if (m_verbose) m_log << m_errors.last().toString() << std::endl;
      }

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 431 of file O3prmrInterpreter.cpp.

References addError(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::chain, gum::Instantiation::end(), gum::Exception::errorContent(), findAttributeName(), findInstanceName(), gum::prm::PRMSystem< GUM_SCALAR >::get(), gum::prm::PRMInstance< 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(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::system, system(), and gum::Instantiation::val().

Referenced by checkSemantic().

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

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 503 of file O3prmrInterpreter.cpp.

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

Referenced by checkSemantic().

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

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 308 of file O3prmrInterpreter.cpp.

References gum::prm::o3prmr::O3prmrSession< GUM_SCALAR >::addCommand(), addError(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::addImport(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::addSession(), checkObserve(), checkQuery(), checkSetEngine(), checkSetGndEngine(), checkUnobserve(), gum::ErrorsContainer::elegantErrorsAndWarnings(), gum::Exception::errorContent(), errors(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::imports(), isInSyntaxMode(), isVerboseMode(), m_context, m_current_line, m_errors, m_log, m_verbose, gum::prm::o3prmr::O3prmrCommand::Observe, gum::prm::o3prmr::O3prmrCommand::Query, gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::sessions(), gum::prm::o3prmr::O3prmrCommand::SetEngine, gum::prm::o3prmr::O3prmrCommand::SetGndEngine, gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::toString(), and gum::prm::o3prmr::O3prmrCommand::Unobserve.

Referenced by interpretFile(), and interpretLine().

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

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 420 of file O3prmrInterpreter.cpp.

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

Referenced by checkSemantic().

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

Here is the caller graph for this function:

checkSetGndEngine()

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

private

Definition at line 425 of file O3prmrInterpreter.cpp.

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

Referenced by checkSemantic().

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

Here is the caller graph for this function:

checkUnobserve()

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

private

Definition at line 478 of file O3prmrInterpreter.cpp.

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

Referenced by checkSemantic().

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

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 105 of file O3prmrInterpreter.cpp.

References m_paths.

{ m_paths.clear(); }

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 935 of file O3prmrInterpreter.cpp.

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

Referenced by error(), and import().

{ return m_errors.count(); }

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 944 of file O3prmrInterpreter.cpp.

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

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

        return m_errors.error(i);
      }

Here is the call graph for this function:

errors()

Size gum::prm::o3prmr::O3prmrInterpreter::errors

(

)

const

of errors

Definition at line 938 of file O3prmrInterpreter.cpp.

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

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

{ return m_errors.error_count; }

Here is the caller graph for this function:

errorsContainer()

ErrorsContainer gum::prm::o3prmr::O3prmrInterpreter::errorsContainer

(

)

const

Return container with all errors.

Definition at line 951 of file O3prmrInterpreter.cpp.

References m_errors.

                                                               {
        return m_errors;
      }

findAttributeName()

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

private

Definition at line 732 of file O3prmrInterpreter.cpp.

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

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

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

        return s;
      }

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 718 of file O3prmrInterpreter.cpp.

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

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

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

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 689 of file O3prmrInterpreter.cpp.

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

Referenced by system().

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

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 891 of file O3prmrInterpreter.cpp.

References addWarning(), gum::prm::PRMSystem< GUM_SCALAR >::groundedBN(), m_bn, m_engine, m_inf, m_inf_map, m_log, m_verbose, and prm().

Referenced by observe(), and query().

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

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 72 of file O3prmrInterpreter.cpp.

References m_context.

                                                                   {
        return 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 88 of file O3prmrInterpreter.cpp.

References m_paths.

                                                               {
        return m_paths;
      }

import()

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

private

Definition at line 531 of file O3prmrInterpreter.cpp.

References gum::Directory::absolutePath(), gum::ErrorsContainer::add(), addError(), count(), gum::ErrorsContainer::count(), gum::ErrorsContainer::error(), gum::Exception::errorContent(), gum::prm::o3prm::O3prmReader< GUM_SCALAR >::errors(), errors(), gum::prm::o3prm::O3prmReader< GUM_SCALAR >::errorsContainer(), gum::prm::o3prmr::O3prmrContext< GUM_SCALAR >::filename(), m_errors, m_log, m_paths, m_reader, m_verbose, gum::prm::o3prm::O3prmReader< GUM_SCALAR >::readFile(), and gum::replace().

                                                                         {
        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()) {
            size_t index = o3prmrFilename.find_last_of('/');

            if (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()) {
              size_t size = filename.find_last_of('/');

              if (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 = Directory(root).absolutePath() + import_name;

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

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 125 of file O3prmrInterpreter.cpp.

References m_inf.

                                                                       {
        return 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 234 of file O3prmrInterpreter.cpp.

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().

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

Here is the call graph for this function:

Here is the caller graph for this function:

interpretFile()

bool gum::prm::o3prmr::O3prmrInterpreter::interpretFile

(

const std::string &

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 143 of file O3prmrInterpreter.cpp.

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

                                                                     {
        m_results.clear();

        try {
          std::string file_content = __readFile(filename);

          delete m_context;
          m_context = new O3prmrContext< double >(filename);
          O3prmrContext< double > c(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; }
      }

Here is the call graph for this function:

interpretLine()

bool gum::prm::o3prmr::O3prmrInterpreter::interpretLine

(

const std::string &

line

)

Definition at line 206 of file O3prmrInterpreter.cpp.

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

                                                                 {
        m_results.clear();

        // On vérifie la syntaxe
        O3prmrContext< double > c;
        Scanner s((unsigned char*)line.c_str(), (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);
      }

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 108 of file O3prmrInterpreter.cpp.

References m_syntax_flag.

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

{ return m_syntax_flag; }

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 114 of file O3prmrInterpreter.cpp.

References m_verbose.

Referenced by checkSemantic(), and interpret().

{ return m_verbose; }

Here is the caller graph for this function:

observe()

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

private

Definition at line 758 of file O3prmrInterpreter.cpp.

References addError(), gum::prm::PRMInference< GUM_SCALAR >::addEvidence(), addWarning(), gum::prm::o3prmr::ObserveCommand< GUM_SCALAR >::chain, gum::Exception::errorContent(), 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().

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

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 120 of file O3prmrInterpreter.cpp.

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

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

                                                        {
        return m_reader->prm();
      }

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 811 of file O3prmrInterpreter.cpp.

References addError(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::chain, gum::prm::o3prmr::QueryResult::command, gum::Instantiation::end(), gum::Exception::errorContent(), generateInfEngine(), gum::MultiDimDecorator< GUM_SCALAR >::get(), GUM_SHOWERROR, gum::Instantiation::inc(), gum::prm::o3prmr::SingleResult::label, gum::DiscreteVariable::label(), m_inf, m_inf_map, m_log, m_results, m_verbose, gum::prm::PRMInference< GUM_SCALAR >::marginal(), gum::Timer::reset(), gum::Instantiation::setFirst(), gum::Timer::step(), gum::prm::o3prmr::QueryCommand< GUM_SCALAR >::system, 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().

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

        Potential< double > m;
        m_inf->marginal(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); }

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 132 of file O3prmrInterpreter.cpp.

References m_results.

                                                                       {
        return m_results;
      }

setContext()

void gum::prm::o3prmr::O3prmrInterpreter::setContext

(

O3prmrContext< double > *

context

)

Setter for the context.

Definition at line 77 of file O3prmrInterpreter.cpp.

References m_context.

                                                                         {
        delete m_context;

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

setEngine()

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

private

Definition at line 881 of file O3prmrInterpreter.cpp.

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

Referenced by interpret().

                                                                       {
        m_engine = command->value;
      }

Here is the caller graph for this function:

setGndEngine()

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

private

Definition at line 886 of file O3prmrInterpreter.cpp.

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

Referenced by interpret().

                                                                             {
        m_bn_engine = command->value;
      }

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 111 of file O3prmrInterpreter.cpp.

References m_syntax_flag.

{ m_syntax_flag = f; }

setVerboseMode()

void gum::prm::o3prmr::O3prmrInterpreter::setVerboseMode

(

bool

f

)

verbose mode show more details on the program execution.

Definition at line 117 of file O3prmrInterpreter.cpp.

References m_verbose.

{ m_verbose = f; }

showElegantErrors()

void gum::prm::o3prmr::O3prmrInterpreter::showElegantErrors

(

std::ostream &

o = std::cerr

)

const

send on std::cerr the list of errors

Definition at line 956 of file O3prmrInterpreter.cpp.

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

                                                                   {
        m_errors.elegantErrors(o);
      }

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 961 of file O3prmrInterpreter.cpp.

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

                                                                              {
        m_errors.elegantErrorsAndWarnings(o);
      }

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 966 of file O3prmrInterpreter.cpp.

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

                                                                 {
        m_errors.syntheticResults(o);
      }

Here is the call graph for this function:

system()

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

private

Definition at line 742 of file O3prmrInterpreter.cpp.

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

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

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

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 788 of file O3prmrInterpreter.cpp.

References addError(), 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().

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

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 941 of file O3prmrInterpreter.cpp.

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

{ return m_errors.warning_count; }

Member Data Documentation

m_bn

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

private

Definition at line 169 of file O3prmrInterpreter.h.

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

m_bn_engine

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

private

Definition at line 174 of file O3prmrInterpreter.h.

Referenced by checkSetGndEngine(), and setGndEngine().

m_context

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

private

Definition at line 166 of file O3prmrInterpreter.h.

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

m_current_line

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

private

Definition at line 180 of file O3prmrInterpreter.h.

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

m_engine

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

private

Definition at line 173 of file O3prmrInterpreter.h.

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

m_errors

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

private

Definition at line 176 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 171 of file O3prmrInterpreter.h.

Referenced by 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 172 of file O3prmrInterpreter.h.

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

m_log

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

private

Definition at line 179 of file O3prmrInterpreter.h.

Referenced by 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 168 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 167 of file O3prmrInterpreter.h.

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

m_results

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

private

Definition at line 175 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 177 of file O3prmrInterpreter.h.

Referenced by isInSyntaxMode(), and setSyntaxMode().

m_verbose

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

private

Definition at line 178 of file O3prmrInterpreter.h.

Referenced by 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