#include <PrologReasoner.h>

Inheritance diagram for knowrob::PrologReasoner:

[legend]

Collaboration diagram for knowrob::PrologReasoner:

[legend]

Public Member Functions
	PrologReasoner ()

	~PrologReasoner () override

	PrologReasoner (const PrologReasoner &)=delete

bool	setReasonerSetting (const TermPtr &key, const TermPtr &valueString)

bool	consult (const std::filesystem::path &uri, const char *module={}, bool doTransformQuery=true)

bool	load_rdf_xml (const std::filesystem::path &rdfFile)

virtual std::string_view	callFunctor ()

PrologTerm	transformGoal (const PrologTerm &goal)

std::list< TermPtr >	runTests (const std::string &target)

bool	initializeReasoner (const PropertyTree &cfg) override

bool	evaluate (GoalPtr query) override

void	unload () override

	PrologReasoner ()

	~PrologReasoner () override

	PrologReasoner (const PrologReasoner &)=delete

bool	setReasonerSetting (const TermPtr &key, const TermPtr &valueString)

bool	consult (const std::filesystem::path &uri, const char *module={}, bool doTransformQuery=true)

bool	load_rdf_xml (const std::filesystem::path &rdfFile)

virtual std::string_view	callFunctor ()

PrologTerm	transformGoal (const PrologTerm &goal)

std::list< TermPtr >	runTests (const std::string &target)

bool	initializeReasoner (const PropertyTree &cfg) override

bool	evaluate (GoalPtr query) override

void	unload () override

Public Member Functions inherited from knowrob::GoalDrivenReasoner
	GoalDrivenReasoner ()

bool	hasFeature (GoalDrivenReasonerFeature feature) const

void	enableFeature (GoalDrivenReasonerFeature feature)

bool	isRelationDefined (const PredicateIndicator &indicator)

bool	isClassDefined (const std::string_view &iri)

void	defineRelation (const PredicateIndicator &indicator)

void	defineRelation (const IRIAtomPtr &iri)

void	undefineRelation (const PredicateIndicator &indicator)

void	defineClass (const IRIAtomPtr &iri)

void	undefineClass (const IRIAtomPtr &iri)

const auto &	definedRelations () const

const auto &	definedClasses () const

	GoalDrivenReasoner ()

bool	hasFeature (GoalDrivenReasonerFeature feature) const

void	enableFeature (GoalDrivenReasonerFeature feature)

bool	isRelationDefined (const PredicateIndicator &indicator)

bool	isClassDefined (const std::string_view &iri)

void	defineRelation (const PredicateIndicator &indicator)

void	defineRelation (const IRIAtomPtr &iri)

void	undefineRelation (const PredicateIndicator &indicator)

void	defineClass (const IRIAtomPtr &iri)

void	undefineClass (const IRIAtomPtr &iri)

const auto &	definedRelations () const

const auto &	definedClasses () const

Public Member Functions inherited from knowrob::Reasoner
	Reasoner ()

virtual	~Reasoner ()=default

auto &	reasonerName () const

auto	reasonerLanguage () const

auto	storage () const

template<class T >
std::shared_ptr< T >	getTypedStorage () const

ReasonerManager &	reasonerManager () const

void	pushWork (const std::function< void(void)> &fn)

void	setStorage (const StoragePtr &storage)

	Reasoner ()

virtual	~Reasoner ()=default

auto &	reasonerName () const

auto	reasonerLanguage () const

auto	storage () const

template<class T >
std::shared_ptr< T >	getTypedStorage () const

ReasonerManager &	reasonerManager () const

void	pushWork (const std::function< void(void)> &fn)

void	setStorage (const StoragePtr &storage)

Public Member Functions inherited from knowrob::DataSourceHandler
	DataSourceHandler ()=default

virtual	~DataSourceHandler ()=default

void	addDataHandler (const std::string &format, const DataSourceLoader &fn)

bool	loadDataSource (const DataSourcePtr &dataSource)

bool	hasDataHandler (const DataSourcePtr &dataSource) const

	DataSourceHandler ()=default

virtual	~DataSourceHandler ()=default

void	addDataHandler (const std::string &format, const DataSourceLoader &fn)

bool	loadDataSource (const DataSourcePtr &dataSource)

bool	hasDataHandler (const DataSourcePtr &dataSource) const

Static Public Member Functions
static std::shared_ptr< NamedReasoner >	getDefinedReasoner (const term_t &t_reasonerManager, const term_t &t_reasonerModule)

static std::shared_ptr< NamedReasoner >	getDefinedReasoner (const term_t &t_reasonerManager, const term_t &t_reasonerModule)

Protected Member Functions
virtual bool	initializeGlobalPackages ()

virtual bool	initializeDefaultPackages ()

virtual void	initializeReasonerStorage ()

bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &dataFile) override

AnswerYesPtr	yes (const GoalPtr &query, const PrologTerm &rdfGoal, const PrologTerm &frameTerm)

AnswerNoPtr	no (const GoalPtr &query)

PrologTerm	getReasonerQuery (const PrologTerm &goal)

virtual bool	initializeGlobalPackages ()

virtual bool	initializeDefaultPackages ()

virtual void	initializeReasonerStorage ()

bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &dataFile) override

AnswerYesPtr	yes (const GoalPtr &query, const PrologTerm &rdfGoal, const PrologTerm &frameTerm)

AnswerNoPtr	no (const GoalPtr &query)

PrologTerm	getReasonerQuery (const PrologTerm &goal)

Static Protected Member Functions
static bool	putQueryFrame (PrologTerm &frameTerm, const GraphSelector &frame)

static std::shared_ptr< GraphSelector >	createAnswerFrame (const PrologTerm &plTerm)

static bool	putQueryFrame (PrologTerm &frameTerm, const GraphSelector &frame)

static std::shared_ptr< GraphSelector >	createAnswerFrame (const PrologTerm &plTerm)

Protected Attributes
std::shared_ptr< PrologBackend >	knowledgeGraph_

Protected Attributes inherited from knowrob::GoalDrivenReasoner
std::set< PredicateIndicator >	definedRelations_

std::set< PredicateIndicator >	definedClasses_

int	features_

Protected Attributes inherited from knowrob::DataSourceHandler
std::map< std::string, DataSourceLoader >	dataSourceHandler_

Static Protected Attributes
static bool	isKnowRobInitialized_ = false

Detailed Description

A Prolog reasoner that answers queries using SWI Prolog.

Definition at line 30 of file PrologReasoner.h.

Constructor & Destructor Documentation

◆ PrologReasoner() [1/4]

PrologReasoner::PrologReasoner ( )

Definition at line 84 of file PrologReasoner.cpp.

                                : GoalDrivenReasoner() {
     // enable goal-driven reasoning features
     enableFeature(GoalDrivenReasonerFeature::SupportsSimpleConjunctions);
     enableFeature(GoalDrivenReasonerFeature::SupportsExtensionalGrounding);
     // add data handler for prolog files
     addDataHandler("prolog", [this]
             (const DataSourcePtr &dataFile) { return consult(dataFile->uri()); });
 }

◆ ~PrologReasoner() [1/2]

PrologReasoner::~PrologReasoner ( )

overridedefault

◆ PrologReasoner() [2/4]

knowrob::PrologReasoner::PrologReasoner ( const PrologReasoner & )

delete

Cannot be copy-assigned.

◆ PrologReasoner() [3/4]

knowrob::PrologReasoner::PrologReasoner ( )

◆ ~PrologReasoner() [2/2]

knowrob::PrologReasoner::~PrologReasoner ( )

override

◆ PrologReasoner() [4/4]

knowrob::PrologReasoner::PrologReasoner ( const PrologReasoner & )

delete

Cannot be copy-assigned.

Member Function Documentation

◆ callFunctor() [1/2]

std::string_view PrologReasoner::callFunctor ( )

virtual

Reimplemented in knowrob::MongologReasoner, and knowrob::MongologReasoner.

Definition at line 100 of file PrologReasoner.cpp.

                                            {
     static const auto reasoner_call_f = "reasoner_call";
     return reasoner_call_f;
 }

◆ callFunctor() [2/2]

virtual std::string_view knowrob::PrologReasoner::callFunctor ( )

virtual

Reimplemented in knowrob::MongologReasoner, and knowrob::MongologReasoner.

◆ consult() [1/2]

bool PrologReasoner::consult	(	const std::filesystem::path &	uri,
		const char *	module = `{}`,
		bool	doTransformQuery = `true`
	)

Consults a Prolog file, i.e. loads facts and rules and executed directives in the file. May throw an exception if there is no valid Prolog file at the given path.

Parameters

uri	the local path to the file.
module	the module to consult the file into.
doTransformQuery	if true, then the file is transformed into a query.

Returns: true on success

Definition at line 187 of file PrologReasoner.cpp.

                                                                                                     {
     static auto consult_f = "consult";
     auto path = PrologEngine::getPrologPath(uri);
  
     return PrologEngine::eval([&]() {
         PrologTerm plTerm(consult_f, path.native());
         if (module) plTerm.setModule(module);
         return getReasonerQuery(doTransformQuery ? transformGoal(plTerm) : plTerm);
     });
 }

◆ consult() [2/2]

bool knowrob::PrologReasoner::consult	(	const std::filesystem::path &	uri,
		const char *	module = `{}`,
		bool	doTransformQuery = `true`
	)

Consults a Prolog file, i.e. loads facts and rules and executed directives in the file. May throw an exception if there is no valid Prolog file at the given path.

Parameters

uri	the local path to the file.
module	the module to consult the file into.
doTransformQuery	if true, then the file is transformed into a query.

Returns: true on success

◆ createAnswerFrame() [1/2]

std::shared_ptr< GraphSelector > PrologReasoner::createAnswerFrame ( const PrologTerm & plTerm )

staticprotected

Definition at line 377 of file PrologReasoner.cpp.

                                                                                        {
     std::shared_ptr<GraphSelector> frame;
  
     if (PL_is_variable(plTerm())) {
         // reasoner did not specify a solution scope
         return {};
     } else if (PL_is_dict(plTerm())) {
         // the solution scope was generated as a Prolog dictionary
         auto scope_val = PL_new_term_ref();
  
         frame = std::make_shared<GraphSelector>();
  
         // read "time" key, the value is expected to be a predicate `range(Since,Until)`
         static const auto time_key = PL_new_atom("time");
         if (PL_get_dict_key(time_key, plTerm(), scope_val)) {
             term_t arg = PL_new_term_ref();
             std::optional<TimePoint> v_since, v_until;
             double val = 0.0;
  
             if (PL_get_arg(1, scope_val, arg) &&
                 PL_term_type(arg) == PL_FLOAT &&
                 PL_get_float(arg, &val) &&
                 val > 0.001) { frame->begin = val; }
  
             if (PL_get_arg(2, scope_val, arg) &&
                 PL_term_type(arg) == PL_FLOAT &&
                 PL_get_float(arg, &val)) { frame->end = val; }
         }
  
         static const auto uncertain_key = PL_new_atom("uncertain");
         if (PL_get_dict_key(uncertain_key, plTerm(), scope_val)) {
             atom_t flagAtom;
             if (PL_term_type(scope_val) == PL_ATOM && PL_get_atom(scope_val, &flagAtom)) {
                 if (flagAtom == PrologTerm::ATOM_true()) {
                     frame->uncertain = true;
                 }
             }
         }
  
         static const auto confidence_key = PL_new_atom("confidence");
         if (PL_get_dict_key(confidence_key, plTerm(), scope_val)) {
             double confidenceValue = 1.0;
             if (PL_term_type(scope_val) == PL_FLOAT && PL_get_float(scope_val, &confidenceValue)) {
                 frame->confidence = confidenceValue;
                 if (confidenceValue > 0.999) {
                     frame->uncertain = false;
                 } else {
                     frame->uncertain = true;
                 }
             }
         }
  
         static const auto occasional_key = PL_new_atom("occasional");
         if (PL_get_dict_key(occasional_key, plTerm(), scope_val)) {
             atom_t flagAtom;
             if (PL_term_type(scope_val) == PL_ATOM && PL_get_atom(scope_val, &flagAtom)) {
                 frame->occasional = (flagAtom == PrologTerm::ATOM_true());
             }
         }
  
         static const auto agent_key = PL_new_atom("agent");
         if (PL_get_dict_key(agent_key, plTerm(), scope_val)) {
             atom_t agentAtom;
             if (PL_term_type(scope_val) == PL_ATOM && PL_get_atom(scope_val, &agentAtom)) {
                 frame->perspective = Perspective::get(PL_atom_chars(agentAtom));
             }
         }
  
         PL_reset_term_refs(scope_val);
     } else {
         KB_WARN("solution scope has an unexpected type (should be dict).");
     }
  
     if (frame) {
         return frame;
     } else {
         return {};
     }
 }

◆ createAnswerFrame() [2/2]

static std::shared_ptr<GraphSelector> knowrob::PrologReasoner::createAnswerFrame ( const PrologTerm & plTerm )

staticprotected

◆ evaluate() [1/2]

bool PrologReasoner::evaluate ( GoalPtr query )

overridevirtual

Evaluate a query with a reasoner. The query is represented by a formula, a context and an answer queue where results of the reasoning process can be added. The evaluation of the query must be performed synchronously, i.e. the answer queue must be filled before the function returns. A reasoner may instead throw an exception if the query cannot be evaluated, or return false to also indicate an error status.

Parameters

query the query to evaluate.

Returns: true on success, false otherwise.

Implements knowrob::GoalDrivenReasoner.

Definition at line 204 of file PrologReasoner.cpp.

                                            {
     // context term options:
     static const auto query_scope_f = "query_scope";
     static const auto solution_scope_f = "solution_scope";
  
     // create runner that evaluates the goal in a thread with a Prolog engine.
     // Note that this is needed because the current thread might not have
     // a Prolog engine associated with it.
     auto runner = std::make_shared<ThreadPool::LambdaRunner>(
             [this, &query](const ThreadPool::LambdaRunner::StopChecker &hasStopRequest) {
                 PrologTerm queryFrame, answerFrame;
                 putQueryFrame(queryFrame, query->ctx()->selector);
  
                 PrologTerm goal(query->formula());
                 // :- ContextTerm = [query_scope(...), solution_scope(Variable)]
                 PrologList contextTerm({
                                                PrologTerm(query_scope_f, queryFrame),
                                                PrologTerm(solution_scope_f, answerFrame)
                                        });
                 // :- QueryGoal = ( b_setval(reasoner_module, reasonerName()),
                 //                  b_setval(reasoner_manager, managerID),
                 //                  reasoner_call(Goal, ContextTerm) ).
                 PrologTerm queryGoal = getReasonerQuery(
                         PrologTerm(callFunctor(), goal, contextTerm));
  
                 auto qid = queryGoal.openQuery(prologQueryFlags);
                 bool hasSolution = false;
                 while (!hasStopRequest() && knowrob::PrologTerm::nextSolution(qid)) {
                     query->push(yes(query, goal, answerFrame));
                     hasSolution = true;
                     if (query->ctx()->queryFlags & QUERY_FLAG_ONE_SOLUTION) break;
                 }
                 PL_close_query(qid);
                 if (!hasSolution) query->push(no(query));
             });
  
     // push goal and return
     PrologEngine::pushGoal(runner, [query](const std::exception &e) {
         KB_WARN("an exception occurred for prolog query ({}): {}.", *query->formula(), e.what());
         throw;
     });
  
     // evaluateQuery must be blocking -> wait on Prolog runner to finish
     runner->join();
  
     return true;
 }

◆ evaluate() [2/2]

bool knowrob::PrologReasoner::evaluate ( GoalPtr query )

overridevirtual

Evaluate a query with a reasoner. The query is represented by a formula, a context and an answer queue where results of the reasoning process can be added. The evaluation of the query must be performed synchronously, i.e. the answer queue must be filled before the function returns. A reasoner may instead throw an exception if the query cannot be evaluated, or return false to also indicate an error status.

Parameters

query the query to evaluate.

Returns: true on success, false otherwise.

Implements knowrob::GoalDrivenReasoner.

◆ getDefinedReasoner() [1/2]

std::shared_ptr< NamedReasoner > PrologReasoner::getDefinedReasoner	(	const term_t &	t_reasonerManager,
		const term_t &	t_reasonerModule
	)

static

Definition at line 167 of file PrologReasoner.cpp.

                                                                          {
     int i_reasonerManager;
     if (!PL_get_integer(t_reasonerManager, &i_reasonerManager)) return {};
     auto reasonerManager = ReasonerManager::getManager(i_reasonerManager);
     if (!reasonerManager) return {};
  
     char *reasonerModule;
     if (PL_get_atom_chars(t_reasonerModule, &reasonerModule)) {
         // remove "reasoner_" prefix from module name.
         // the prefix is used to avoid name clashes.
         if (strncmp(reasonerModule, "Reasoner_", 9) == 0) {
             reasonerModule += 9;
         }
         return reasonerManager->getPluginWithID(reasonerModule);
     } else {
         return {};
     }
 }

◆ getDefinedReasoner() [2/2]

static std::shared_ptr<NamedReasoner> knowrob::PrologReasoner::getDefinedReasoner	(	const term_t &	t_reasonerManager,
		const term_t &	t_reasonerModule
	)

static

◆ getReasonerQuery() [1/2]

PrologTerm PrologReasoner::getReasonerQuery ( const PrologTerm & goal )

protected

Definition at line 157 of file PrologReasoner.cpp.

                                                                   {
     static const auto b_setval_f = "b_setval";
     static const auto reasoner_module_a = "reasoner_module";
     static const auto reasoner_manager_a = "reasoner_manager";
     auto managerID = std::make_shared<Integer>(reasonerManager().managerID());
     return PrologTerm(b_setval_f, reasoner_module_a, reasonerName()) &
            PrologTerm(b_setval_f, reasoner_manager_a, managerID) &
            goal;
 }

◆ getReasonerQuery() [2/2]

PrologTerm knowrob::PrologReasoner::getReasonerQuery ( const PrologTerm & goal )

protected

◆ initializeDefaultPackages() [1/2]

virtual bool knowrob::PrologReasoner::initializeDefaultPackages ( )

inlineprotectedvirtual

Reimplemented in knowrob::SWRLReasoner, knowrob::MongologReasoner, knowrob::ESGReasoner, knowrob::SWRLReasoner, knowrob::MongologReasoner, and knowrob::ESGReasoner.

Definition at line 91 of file PrologReasoner.h.

91 { return true; }

◆ initializeDefaultPackages() [2/2]

virtual bool knowrob::PrologReasoner::initializeDefaultPackages ( )

inlineprotectedvirtual

Reimplemented in knowrob::SWRLReasoner, knowrob::MongologReasoner, knowrob::ESGReasoner, knowrob::SWRLReasoner, knowrob::MongologReasoner, and knowrob::ESGReasoner.

Definition at line 91 of file PrologReasoner.h.

91 { return true; }

◆ initializeGlobalPackages() [1/2]

virtual bool knowrob::PrologReasoner::initializeGlobalPackages ( )

inlineprotectedvirtual

Definition at line 89 of file PrologReasoner.h.

89 { return true; }

◆ initializeGlobalPackages() [2/2]

virtual bool knowrob::PrologReasoner::initializeGlobalPackages ( )

inlineprotectedvirtual

Definition at line 89 of file PrologReasoner.h.

89 { return true; }

◆ initializeReasoner() [1/2]

bool PrologReasoner::initializeReasoner ( const PropertyTree & ptree )

overridevirtual

Initialize a reasoner by configuring it with a property tree.

Parameters

ptree a PropertyTree object.

Implements knowrob::Reasoner.

Reimplemented in knowrob::MongologReasoner.

Definition at line 109 of file PrologReasoner.cpp.

                                                                {
     // call PL_initialize
     PrologEngine::initializeProlog();
     initializeReasonerStorage();
  
     if (!isKnowRobInitialized_) {
         isKnowRobInitialized_ = true;
  
         PL_register_foreign("reasoner_define_relation_cpp", 4, (pl_function_t) prolog::reasoner_define_relation4, 0);
         PL_register_foreign("reasoner_define_class_cpp", 3, (pl_function_t) prolog::reasoner_define_class3, 0);
  
         // auto-load some files into "user" module
         initializeGlobalPackages();
  
         // load init file from reasoner directory
         consult(std::filesystem::path("reasoner") / "prolog" / "__init__.pl", "user", false);
  
         // register RDF namespaces with Prolog.
         // in particular the ones specified in settings are globally registered with PrefixRegistry.
         static const auto register_prefix_i = "rdf_register_prefix";
         for (auto &pair: PrefixRegistry::get()) {
             const auto &uri = pair.first;
             const auto &alias = pair.second;
             PROLOG_REASONER_EVAL(PrologTerm(register_prefix_i, alias, uri));
         }
     }
  
     // load properties into the reasoner module.
     // this is needed mainly for `reasoner_setting/2` that provides reasoner instance specific settings.
     for (auto &pair: cfg) {
         auto key_t = cfg.createKeyTerm(pair.first);
         setReasonerSetting(key_t, pair.second);
     }
     // load reasoner default packages. this is usually the code that implements the reasoner.
     initializeDefaultPackages();
  
     // this is needed to assert triple/3 predicate in the reasoner module
     static auto reasoner_rdf_init_f = "reasoner_rdf_init";
     PROLOG_REASONER_EVAL(PrologTerm(reasoner_rdf_init_f));
  
     return true;
 }

◆ initializeReasoner() [2/2]

bool knowrob::PrologReasoner::initializeReasoner ( const PropertyTree & ptree )

overridevirtual

Initialize a reasoner by configuring it with a property tree.

Parameters

ptree a PropertyTree object.

Implements knowrob::Reasoner.

◆ initializeReasonerStorage() [1/2]

virtual void knowrob::PrologReasoner::initializeReasonerStorage ( )

inlineprotectedvirtual

Reimplemented in knowrob::MongologReasoner, and knowrob::MongologReasoner.

Definition at line 93 of file PrologReasoner.h.

93 { knowledgeGraph_ = getTypedStorage<PrologBackend>(); }

knowrob::PrologReasoner::knowledgeGraph_

std::shared_ptr< PrologBackend > knowledgeGraph_

Definition: PrologReasoner.h:87

◆ initializeReasonerStorage() [2/2]

virtual void knowrob::PrologReasoner::initializeReasonerStorage ( )

inlineprotectedvirtual

Reimplemented in knowrob::MongologReasoner, and knowrob::MongologReasoner.

Definition at line 93 of file PrologReasoner.h.

93 { knowledgeGraph_ = getTypedStorage<PrologBackend>(); }

◆ load_rdf_xml() [1/2]

bool PrologReasoner::load_rdf_xml ( const std::filesystem::path & rdfFile )

Parameters

rdfFile a rdf-xml encoded file.

Definition at line 198 of file PrologReasoner.cpp.

                                                                   {
     static auto load_rdf_xml_f = "load_rdf_xml";
     auto path = PrologEngine::getResourcePath(rdfFile);
     return PROLOG_REASONER_EVAL(PrologTerm(load_rdf_xml_f, path.native(), reasonerName()));
 }

◆ load_rdf_xml() [2/2]

bool knowrob::PrologReasoner::load_rdf_xml ( const std::filesystem::path & rdfFile )

Parameters

rdfFile a rdf-xml encoded file.

◆ loadDataSourceWithUnknownFormat() [1/2]

bool knowrob::PrologReasoner::loadDataSourceWithUnknownFormat ( const DataSourcePtr & dataFile )

inlineoverrideprotectedvirtual

Reimplemented from knowrob::DataSourceHandler.

Definition at line 95 of file PrologReasoner.h.

                                                                                      {
             return consult(dataFile->uri());
         };

◆ loadDataSourceWithUnknownFormat() [2/2]

bool knowrob::PrologReasoner::loadDataSourceWithUnknownFormat ( const DataSourcePtr & dataFile )

inlineoverrideprotectedvirtual

Reimplemented from knowrob::DataSourceHandler.

Definition at line 95 of file PrologReasoner.h.

                                                                                      {
             return consult(dataFile->uri());
         };

◆ no() [1/2]

AnswerNoPtr PrologReasoner::no ( const GoalPtr & query )

protected

Definition at line 291 of file PrologReasoner.cpp.

                                                    {
     KB_DEBUG("Prolog has no solution.");
     // if no solution was found, indicate that via a NegativeAnswer.
     auto negativeAnswer = std::make_shared<AnswerNo>();
     negativeAnswer->setReasonerTerm(reasonerName());
     // however, as Prolog cannot proof negations such an answer is always not well-founded
     // and can be overruled by a well-founded one.
     negativeAnswer->setIsUncertain(true, std::nullopt);
  
     // add literals to the answer for which the query has failed.
     // NOTE: At the moment negations will only appear in simple queries
     //       without connective operators, so no problem that below we can
     //       only handle queries with a single literal.
     auto &literals = query->formula()->literals();
     if (literals.size() == 1) {
         auto &firstLiteral = *literals.begin();
         negativeAnswer->addUngrounded(
                 std::static_pointer_cast<Predicate>(firstLiteral->predicate()),
                 firstLiteral->isNegated());
     }
  
     return negativeAnswer;
 }

◆ no() [2/2]

AnswerNoPtr knowrob::PrologReasoner::no ( const GoalPtr & query )

protected

◆ putQueryFrame() [1/2]

bool PrologReasoner::putQueryFrame	(	PrologTerm &	frameTerm,
		const GraphSelector &	frame
	)

staticprotected

Definition at line 316 of file PrologReasoner.cpp.

                                                                                     {
     // Map an GraphSelector to a Prolog dict term.
     // The term has the form:
     // { epistemicMode: knowledge|belief,
     //   temporalMode: sometimes|always,
     //   [agent: $name,]
     //   [since: $time,]
     //   [until: $time] }
  
     int numFrameKeys = 2;
     if (frame.perspective) numFrameKeys += 1;
     if (frame.begin.has_value()) numFrameKeys += 1;
     if (frame.end.has_value()) numFrameKeys += 1;
  
     // option: frame($dictTerm)
     atom_t scopeKeys[numFrameKeys];
     auto scopeValues = PL_new_term_refs(numFrameKeys);
  
     // epistemicMode: knowledge|belief
     static const auto epistemicMode_a = PL_new_atom("epistemicMode");
     static const auto knowledge_a = PL_new_atom("knowledge");
     static const auto belief_a = PL_new_atom("belief");
  
     bool isAboutBelief = (frame.uncertain);
     int keyIndex = 0;
     scopeKeys[keyIndex] = epistemicMode_a;
     if (!PL_put_atom(scopeValues, isAboutBelief ? belief_a : knowledge_a)) return false;
  
     // temporalMode: sometimes|always
     static const auto temporalMode_a = PL_new_atom("temporalMode");
     static const auto sometimes_a = PL_new_atom("sometimes");
     static const auto always_a = PL_new_atom("always");
  
     bool isAboutSomePast = (frame.occasional);
     scopeKeys[++keyIndex] = temporalMode_a;
     if (!PL_put_atom(scopeValues + keyIndex, isAboutSomePast ? sometimes_a : always_a)) return false;
  
     // agent: $name
     if (frame.perspective) {
         static const auto agent_a = PL_new_atom("agent");
         scopeKeys[++keyIndex] = agent_a;
         auto agent_iri = frame.perspective->iri();
         if (!PL_put_atom_chars(scopeValues + keyIndex, agent_iri.data())) return false;
     }
  
     // since: $name
     if (frame.begin.has_value()) {
         static const auto since_a = PL_new_atom("since");
         scopeKeys[++keyIndex] = since_a;
         if (!PL_put_float(scopeValues + keyIndex, frame.begin.value())) return false;
     }
     // until: $name
     if (frame.end.has_value()) {
         static const auto until_a = PL_new_atom("until");
         scopeKeys[++keyIndex] = until_a;
         if (!PL_put_float(scopeValues + keyIndex, frame.end.value())) return false;
     }
  
     return PL_put_dict(frameTerm(), 0, numFrameKeys, scopeKeys, scopeValues);
 }

◆ putQueryFrame() [2/2]

static bool knowrob::PrologReasoner::putQueryFrame	(	PrologTerm &	frameTerm,
		const GraphSelector &	frame
	)

staticprotected

◆ runTests() [1/2]

std::list< TermPtr > PrologReasoner::runTests ( const std::string & target )

Definition at line 457 of file PrologReasoner.cpp.

                                                                  {
     static const auto xunit_var = std::make_shared<Variable>("Term");
     static const auto silent_flag = Atom::Tabled("silent");
     static const auto xunit_opt = std::make_shared<Function>(Function("xunit_term", {xunit_var}));
  
     TermPtr pred = std::make_shared<Function>(Function(
             "test_and_report", {
                     // unittest target
                     Atom::Tabled(target),
                     // options
                     std::make_shared<ListTerm>(ListTerm({xunit_opt, silent_flag}))
             }));
     auto solutions = PROLOG_ENGINE_ALL_SOL(getReasonerQuery(PrologTerm(pred)));
  
     std::list<TermPtr> output;
     for (auto &solution: solutions) {
         if (solution.count(*xunit_var) > 0) {
             output.push_back(solution[*xunit_var]);
         } else {
             KB_WARN("Solution has no key '{}'.", xunit_var->name());
         }
     }
     return output;
 }

◆ runTests() [2/2]

std::list<TermPtr> knowrob::PrologReasoner::runTests ( const std::string & target )

◆ setReasonerSetting() [1/2]

bool PrologReasoner::setReasonerSetting	(	const TermPtr &	key,
		const TermPtr &	valueString
	)

Parameters

key
valueString

Returns

Definition at line 152 of file PrologReasoner.cpp.

                                                                                       {
     static auto set_setting_f = "reasoner_set_setting";
     return PROLOG_REASONER_EVAL(PrologTerm(set_setting_f, reasonerName(), key, valueString));
 }

◆ setReasonerSetting() [2/2]

bool knowrob::PrologReasoner::setReasonerSetting	(	const TermPtr &	key,
		const TermPtr &	valueString
	)

Parameters

key
valueString

Returns

◆ transformGoal() [1/2]

PrologTerm PrologReasoner::transformGoal ( const PrologTerm & goal )

Definition at line 105 of file PrologReasoner.cpp.

                                                                {
     return PrologTerm(callFunctor(), goal, PrologTerm::nil());
 }

◆ transformGoal() [2/2]

PrologTerm knowrob::PrologReasoner::transformGoal ( const PrologTerm & goal )

◆ unload() [1/2]

void PrologReasoner::unload ( )

overridevirtual

Unload the reasoner, meaning that all static resources associated to this reasoner are released.

Reimplemented from knowrob::Reasoner.

Reimplemented in knowrob::SWRLReasoner, knowrob::MongologReasoner, and knowrob::SWRLReasoner.

Definition at line 95 of file PrologReasoner.cpp.

                             {
     static auto unload_f = "reasoner_unload";
     PROLOG_ENGINE_EVAL(getReasonerQuery(PrologTerm(unload_f)));
 }

◆ unload() [2/2]

void knowrob::PrologReasoner::unload ( )

overridevirtual

Unload the reasoner, meaning that all static resources associated to this reasoner are released.

Reimplemented from knowrob::Reasoner.

Reimplemented in knowrob::SWRLReasoner.

◆ yes() [1/2]

AnswerYesPtr PrologReasoner::yes	(	const GoalPtr &	query,
		const PrologTerm &	rdfGoal,
		const PrologTerm &	frameTerm
	)

protected

Definition at line 252 of file PrologReasoner.cpp.

                                                                     {
     KB_DEBUG("Prolog has a next solution.");
  
     // create bindings object
     auto bindings = std::make_shared<Bindings>();
     for (const auto &kv: rdfGoal.vars()) {
         auto grounding = PrologTerm::toKnowRobTerm(kv.second);
         if (grounding && grounding->termType() != TermType::VARIABLE) {
             bindings->set(std::make_shared<Variable>(kv.first), PrologTerm::toKnowRobTerm(kv.second));
         }
     }
  
     // create an answer object given the bindings
     auto yes = std::make_shared<AnswerYes>(bindings);
     yes->setReasonerTerm(reasonerName());
  
     // set the solution scope, if reasoner specified it
     auto answerFrame_rw = createAnswerFrame(answerFrameTerm);
     GraphSelectorPtr answerFrame_ro;
     if (answerFrame_rw) {
         yes->setFrame(answerFrame_rw);
         answerFrame_ro = answerFrame_rw;
     } else {
         answerFrame_ro = DefaultGraphSelector();
     }
  
     // store instantiations of literals
     auto &phi = query->formula();
     for (auto &literal: phi->literals()) {
         auto &p = literal->predicate();
         auto p_instance = applyBindings(p, *yes->substitution());
         yes->addGrounding(std::static_pointer_cast<Predicate>(p_instance), literal->isNegated(), answerFrame_ro);
     }
  
     return yes;
 }

◆ yes() [2/2]

AnswerYesPtr knowrob::PrologReasoner::yes	(	const GoalPtr &	query,
		const PrologTerm &	rdfGoal,
		const PrologTerm &	frameTerm
	)

protected

Member Data Documentation

◆ isKnowRobInitialized_

bool PrologReasoner::isKnowRobInitialized_ = false

staticprotected

Definition at line 86 of file PrologReasoner.h.

◆ knowledgeGraph_

std::shared_ptr< PrologBackend > knowrob::PrologReasoner::knowledgeGraph_

protected

Definition at line 87 of file PrologReasoner.h.

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

build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/reasoner/prolog/PrologReasoner.h
src/reasoner/prolog/PrologReasoner.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PrologReasoner() [1/4]

◆ ~PrologReasoner() [1/2]

◆ PrologReasoner() [2/4]

◆ PrologReasoner() [3/4]

◆ ~PrologReasoner() [2/2]

◆ PrologReasoner() [4/4]

Member Function Documentation

◆ callFunctor() [1/2]

◆ callFunctor() [2/2]

◆ consult() [1/2]

◆ consult() [2/2]

◆ createAnswerFrame() [1/2]

◆ createAnswerFrame() [2/2]

◆ evaluate() [1/2]

◆ evaluate() [2/2]

◆ getDefinedReasoner() [1/2]

◆ getDefinedReasoner() [2/2]

◆ getReasonerQuery() [1/2]

◆ getReasonerQuery() [2/2]

◆ initializeDefaultPackages() [1/2]

◆ initializeDefaultPackages() [2/2]

◆ initializeGlobalPackages() [1/2]

◆ initializeGlobalPackages() [2/2]

◆ initializeReasoner() [1/2]

◆ initializeReasoner() [2/2]

◆ initializeReasonerStorage() [1/2]

◆ initializeReasonerStorage() [2/2]

◆ load_rdf_xml() [1/2]

◆ load_rdf_xml() [2/2]

◆ loadDataSourceWithUnknownFormat() [1/2]

◆ loadDataSourceWithUnknownFormat() [2/2]

◆ no() [1/2]

◆ no() [2/2]

◆ putQueryFrame() [1/2]

◆ putQueryFrame() [2/2]

◆ runTests() [1/2]

◆ runTests() [2/2]

◆ setReasonerSetting() [1/2]

◆ setReasonerSetting() [2/2]

◆ transformGoal() [1/2]

◆ transformGoal() [2/2]

◆ unload() [1/2]

◆ unload() [2/2]

◆ yes() [1/2]

◆ yes() [2/2]

Member Data Documentation

◆ isKnowRobInitialized_

◆ knowledgeGraph_