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 69 of file O3prmrInterpreter.h.

Constructor & Destructor Documentation

O3prmrInterpreter()

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

(

)

This constructor create an empty context.

Definition at line 53 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 59 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;
      }

Member Function Documentation

_readFile_()

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

private

Definition at line 176 of file O3prmrInterpreter.cpp.

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

addError()

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

private

Definition at line 926 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;
      }

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

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

addWarning()

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

private

Definition at line 933 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;
      }

checkObserve()

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

private

Definition at line 413 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.
          // 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;
      }

checkQuery()

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

private

Definition at line 479 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;
      }

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

checkSetEngine()

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

private

Definition at line 403 of file O3prmrInterpreter.cpp.

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

checkSetGndEngine()

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

private

Definition at line 408 of file O3prmrInterpreter.cpp.

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

checkUnobserve()

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

private

Definition at line 456 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;
      }

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

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

{ return m_errors.count(); }

error()

ParseError gum::prm::o3prmr::O3prmrInterpreter::error

(

Idx

i

)

const

throw a string error if i >= count

Definition at line 898 of file O3prmrInterpreter.cpp.

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

        return m_errors.error(i);
      }

errors()

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

(

)

const

of errors

Definition at line 892 of file O3prmrInterpreter.cpp.

{ return m_errors.error_count; }

errorsContainer()

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

(

)

const

Return container with all errors.

Definition at line 905 of file O3prmrInterpreter.cpp.

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

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

        return s;
      }

findInstanceName()

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

private

Definition at line 683 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;
      }

findSystemName()

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

private

Definition at line 655 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 + "'.";
      }

generateInfEngine()

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

private

Definition at line 846 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;
      }

getContext()

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

(

)

const

Getter and setter for the context.

Getter for the context.

Definition at line 73 of file O3prmrInterpreter.cpp.

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

{ return m_paths; }

import()

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

private

Definition at line 505 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()) {
            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;
        }
      }

inference()

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

(

)

const

Retrieve inference motor object.

Definition at line 120 of file O3prmrInterpreter.cpp.

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

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

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

interpretLine()

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

(

const std::string &

line

)

Definition at line 197 of file O3prmrInterpreter.cpp.

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

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

{ return m_syntax_flag; }

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

{ return m_verbose; }

observe()

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

private

Definition at line 719 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;
      }

prm()

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

(

)

const

Retrieve prm object.

Definition at line 117 of file O3prmrInterpreter.cpp.

{ return m_reader->prm(); }

query()

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

private

Definition at line 769 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();

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

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

{ return m_results; }

setContext()

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

(

O3prmrContext< double > *

context

)

Setter for the context.

Definition at line 76 of file O3prmrInterpreter.cpp.

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

                                                                       {
        m_engine = command->value;
      }

setGndEngine()

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

private

Definition at line 841 of file O3prmrInterpreter.cpp.

                                                                             {
        m_bn_engine = command->value;
      }

setSyntaxMode()

void gum::prm::o3prmr::O3prmrInterpreter::setSyntaxMode

(

bool

f

)

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

Definition at line 108 of file O3prmrInterpreter.cpp.

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

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

                                                                   {
        m_errors.elegantErrors(o);
      }

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

                                                                              {
        m_errors.elegantErrorsAndWarnings(o);
      }

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

                                                                 {
        m_errors.syntheticResults(o);
      }

system()

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

private

Definition at line 705 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.";
      }

unobserve()

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

private

Definition at line 748 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;
      }

warnings()

Size gum::prm::o3prmr::O3prmrInterpreter::warnings

(

)

const

of warnings

Definition at line 895 of file O3prmrInterpreter.cpp.

{ return m_errors.warning_count; }

Member Data Documentation

m_bn

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

private

Definition at line 168 of file O3prmrInterpreter.h.

m_bn_engine

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

private

Definition at line 173 of file O3prmrInterpreter.h.

m_context

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

private

Definition at line 165 of file O3prmrInterpreter.h.

m_current_line

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

private

Definition at line 179 of file O3prmrInterpreter.h.

m_engine

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

private

Definition at line 172 of file O3prmrInterpreter.h.

m_errors

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

private

Definition at line 175 of file O3prmrInterpreter.h.

m_inf

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

private

Definition at line 170 of file O3prmrInterpreter.h.

m_inf_map

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

private

Definition at line 171 of file O3prmrInterpreter.h.

m_log

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

private

Definition at line 178 of file O3prmrInterpreter.h.

m_paths

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

private

Definition at line 167 of file O3prmrInterpreter.h.

m_reader

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

private

Definition at line 166 of file O3prmrInterpreter.h.

m_results

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

private

Definition at line 174 of file O3prmrInterpreter.h.

m_syntax_flag

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

private

Definition at line 176 of file O3prmrInterpreter.h.

m_verbose

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

private

Definition at line 177 of file O3prmrInterpreter.h.

---

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

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