#include <ReasonerManager.h>

Inheritance diagram for knowrob::ReasonerManager:

Collaboration diagram for knowrob::ReasonerManager:

Public Member Functions
	ReasonerManager (KnowledgeBase *kb, const std::shared_ptr< StorageManager > &backendManager)

	~ReasonerManager () override

auto	kb () const

auto	backendManager () const

auto &	goalDriven () const

auto &	dataDriven () const

std::vector< DefiningReasoner >	findDefiningReasoner (const PredicateIndicator &indicator) const

std::shared_ptr< Storage >	getReasonerStorage (const std::shared_ptr< NamedReasoner > &reasoner)

std::shared_ptr< NamedReasoner >	loadPlugin (const boost::property_tree::ptree &config) override

std::shared_ptr< NamedReasoner >	addPlugin (std::string_view reasonerID, PluginLanguage language, const std::shared_ptr< Reasoner > &reasoner) override

	ReasonerManager (KnowledgeBase *kb, const std::shared_ptr< StorageManager > &backendManager)

	~ReasonerManager () override

auto	kb () const

auto	backendManager () const

auto &	goalDriven () const

auto &	dataDriven () const

std::vector< DefiningReasoner >	findDefiningReasoner (const PredicateIndicator &indicator) const

std::shared_ptr< Storage >	getReasonerStorage (const std::shared_ptr< NamedReasoner > &reasoner)

std::shared_ptr< NamedReasoner >	loadPlugin (const boost::property_tree::ptree &config) override

std::shared_ptr< NamedReasoner >	addPlugin (std::string_view reasonerID, PluginLanguage language, const std::shared_ptr< Reasoner > &reasoner) override

Public Member Functions inherited from knowrob::PluginManager< Reasoner >
	PluginManager ()

	PluginManager ()

virtual	~PluginManager ()

virtual	~PluginManager ()

auto	managerID () const

auto	managerID () const

const auto &	plugins () const

const auto &	plugins () const

std::shared_ptr< NamedPlugin< Reasoner > >	getPluginWithID (std::string_view pluginID)

std::shared_ptr< NamedPlugin< Reasoner > >	getPluginWithID (std::string_view pluginID)

void	removePlugin (const std::shared_ptr< NamedPlugin< Reasoner >> &namedPlugin)

void	removePlugin (std::string_view pluginID)

void	removePlugin (const std::shared_ptr< NamedPlugin< Reasoner >> &namedPlugin)

void	removePlugin (std::string_view pluginID)

Static Public Member Functions
static TokenBufferPtr	evaluateQuery (const GoalDrivenReasonerPtr &reasoner, const std::vector< FirstOrderLiteralPtr > &literals, const QueryContextPtr &ctx)

static TokenBufferPtr	evaluateQuery (const GoalDrivenReasonerPtr &reasoner, const std::vector< FirstOrderLiteralPtr > &literals, const QueryContextPtr &ctx)

Static Public Member Functions inherited from knowrob::PluginManager< Reasoner >
static PluginManager< Reasoner > *	getManager (uint32_t managerID)

static PluginManager< Reasoner > *	getManager (uint32_t managerID)

static bool	addFactory (std::string_view typeName, const std::shared_ptr< PluginFactory< Reasoner >> &factory)

static bool	addFactory (std::string_view typeName)

static bool	addFactory (std::string_view typeName, const std::shared_ptr< PluginFactory< Reasoner >> &factory)

static bool	addFactory (std::string_view typeName)

Additional Inherited Members
Protected Member Functions inherited from knowrob::PluginManager< Reasoner >
std::shared_ptr< PluginLibrary< Reasoner > >	loadSharedLibrary (std::string_view path)

std::shared_ptr< PluginLibrary< Reasoner > >	loadSharedLibrary (std::string_view path)

std::shared_ptr< PluginModule< Reasoner > >	loadPythonModule (std::string_view path, std::string_view type)

std::shared_ptr< PluginModule< Reasoner > >	loadPythonModule (std::string_view path, std::string_view type)

std::shared_ptr< PluginFactory< Reasoner > >	findFactory (const boost::property_tree::ptree &config)

std::shared_ptr< PluginFactory< Reasoner > >	findFactory (const boost::property_tree::ptree &config)

std::string	getPluginID (const std::shared_ptr< PluginFactory< Reasoner >> &factory, const boost::property_tree::ptree &config)

std::string	getPluginID (const std::shared_ptr< PluginFactory< Reasoner >> &factory, const boost::property_tree::ptree &config)

Static Protected Member Functions inherited from knowrob::PluginManager< Reasoner >
static uint32_t &	managerIDCounter ()

static uint32_t &	managerIDCounter ()

static auto &	pluginFactories ()

static auto &	pluginFactories ()

static auto &	pluginManagers ()

static auto &	pluginManagers ()

Protected Attributes inherited from knowrob::PluginManager< Reasoner >
std::shared_ptr< std::map< uint32_t, PluginManager * > >	pluginManagers_

std::mutex	staticMutex_

uint32_t	managerID_

uint32_t	pluginIndex_

std::map< std::string_view, std::shared_ptr< NamedPlugin< Reasoner > >, std::less<> >	pluginPool_

std::map< std::string, std::shared_ptr< PluginLibrary< Reasoner > >, std::less<> >	loadedPlugins_

std::map< std::string, std::shared_ptr< PluginModule< Reasoner > >, std::less<> >	loadedModules_

Detailed Description

Manages a set of available reasoning subsystems.

Definition at line 19 of file ReasonerManager.h.

Constructor & Destructor Documentation

◆ ReasonerManager() [1/2]

ReasonerManager::ReasonerManager	(	KnowledgeBase *	kb,
		const std::shared_ptr< StorageManager > &	backendManager
	)

Create a new reasoner manager.

Parameters

kb	the knowledge base associated with this manager.
backendManager	the backend manager associated with this manager.

Definition at line 12 of file ReasonerManager.cpp.

         : PluginManager(),
           kb_(kb),
           backendManager_(backendManager) {
 }

◆ ~ReasonerManager() [1/2]

ReasonerManager::~ReasonerManager ( )

override

Definition at line 18 of file ReasonerManager.cpp.

                                   {
     std::lock_guard<std::mutex> scoped_lock(staticMutex_);
     for (auto &x: pluginPool_) {
         x.second->value()->unload();
         // make sure reasoner does not interact with the manager anymore
         x.second->value()->setReasonerManager(nullptr);
     }
     pluginPool_.clear();
 }

◆ ReasonerManager() [2/2]

knowrob::ReasonerManager::ReasonerManager	(	KnowledgeBase *	kb,
		const std::shared_ptr< StorageManager > &	backendManager
	)

Create a new reasoner manager.

Parameters

kb	the knowledge base associated with this manager.
backendManager	the backend manager associated with this manager.

◆ ~ReasonerManager() [2/2]

knowrob::ReasonerManager::~ReasonerManager ( )

override

Member Function Documentation

◆ addPlugin() [1/2]

std::shared_ptr< NamedReasoner > ReasonerManager::addPlugin	(	std::string_view	reasonerID,
		PluginLanguage	language,
		const std::shared_ptr< Reasoner > &	reasoner
	)

overridevirtual

Add a plugin to this manager.

Parameters

reasonerID	the name of the reasoner
language	the language of the plugin
reasoner	the reasoner instance

Implements knowrob::PluginManager< Reasoner >.

Definition at line 147 of file ReasonerManager.cpp.

                                                                                                                       {
     if (pluginPool_.find(reasonerID) != pluginPool_.end()) {
         KB_WARN("overwriting reasoner with name '{}'", reasonerID);
     }
     auto managedReasoner = std::make_shared<NamedReasoner>(reasonerID, language, reasoner);
     pluginPool_.emplace(managedReasoner->name(), managedReasoner);
     reasoner->setReasonerManager(this);
     reasoner->setReasonerName(reasonerID);
     initPlugin(managedReasoner);
     // indicate that the origin `reasonerID` is a reasoner, and thus belongs to the session
     backendManager_->vocabulary()->importHierarchy()->addDirectImport(
             backendManager_->vocabulary()->importHierarchy()->ORIGIN_REASONER, reasonerID);
  
     // check if reasoner implements DataBackend interface
     auto backend = std::dynamic_pointer_cast<Storage>(reasoner);
     if (backend) {
         setReasonerStorage(managedReasoner, backend);
         backendManager_->addPlugin(reasonerID, language, backend);
     }
  
     return managedReasoner;
 }

◆ addPlugin() [2/2]

std::shared_ptr<NamedReasoner> knowrob::ReasonerManager::addPlugin	(	std::string_view	reasonerID,
		PluginLanguage	language,
		const std::shared_ptr< Reasoner > &	reasoner
	)

overridevirtual

Add a plugin to this manager.

Parameters

reasonerID	the name of the reasoner
language	the language of the plugin
reasoner	the reasoner instance

Implements knowrob::PluginManager< Reasoner >.

◆ backendManager() [1/2]

auto knowrob::ReasonerManager::backendManager ( ) const

inline

Returns: the backend manager associated with this manager.

Definition at line 38 of file ReasonerManager.h.

38 { return backendManager_; }

◆ backendManager() [2/2]

auto knowrob::ReasonerManager::backendManager ( ) const

inline

Returns: the backend manager associated with this manager.

Definition at line 38 of file ReasonerManager.h.

38 { return backendManager_; }

◆ dataDriven() [1/2]

auto& knowrob::ReasonerManager::dataDriven ( ) const

inline

Returns: the data-driven reasoners defined by this manager.

Definition at line 48 of file ReasonerManager.h.

48 { return dataDriven_; }

◆ dataDriven() [2/2]

auto& knowrob::ReasonerManager::dataDriven ( ) const

inline

Returns: the data-driven reasoners defined by this manager.

Definition at line 48 of file ReasonerManager.h.

48 { return dataDriven_; }

◆ evaluateQuery() [1/2]

TokenBufferPtr ReasonerManager::evaluateQuery	(	const GoalDrivenReasonerPtr &	reasoner,
		const std::vector< FirstOrderLiteralPtr > &	literals,
		const QueryContextPtr &	ctx
	)

static

Evaluate a query using a goal-driven reasoner.

Parameters

reasoner	the reasoner to use.
literals	the query to evaluate.
ctx	the query context.

Returns: a buffer that can be used to retrieve the results of the query.

Definition at line 196 of file ReasonerManager.cpp.

                                     {
     auto reasonerRunner = std::make_shared<ReasonerRunner>();
     reasonerRunner->reasoner = reasoner;
     if(literals.size()>1) {
         auto conjunction = std::make_shared<SimpleConjunction>(literals);
         reasonerRunner->query = std::make_shared<Goal>(conjunction, ctx);
     } else if (literals.size() == 1) {
         reasonerRunner->query = std::make_shared<Goal>(literals[0], ctx);
     } else {
         throw ReasonerError("Reasoner {} received an empty query.", *reasoner->reasonerName());
     }
     KB_DEBUG("Evaluating query `{}` with reasoner \"{}\"",
             *reasonerRunner->query->formula(), *reasoner->reasonerName());
     // avoid that the exception handler keeps a reference to the reasonerRunner as
     // this would prevent the runner from being destroyed.
     auto reasonerRunnerPtr = reasonerRunner.get();
     // run reasoner in a thread
     DefaultThreadPool()->pushWork(
             reasonerRunner,
             [reasonerRunnerPtr](const std::exception &exc) {
                 KB_ERROR("Reasoner {} produced an error in query evaluation. {} [{}]",
                          *reasonerRunnerPtr->reasoner->reasonerName(), exc.what(), *reasonerRunnerPtr->query->formula());
                 reasonerRunnerPtr->query->finish();
             });
     // return the (incomplete) answer buffer
     return reasonerRunner->query->answerBuffer();
 }

◆ evaluateQuery() [2/2]

static TokenBufferPtr knowrob::ReasonerManager::evaluateQuery	(	const GoalDrivenReasonerPtr &	reasoner,
		const std::vector< FirstOrderLiteralPtr > &	literals,
		const QueryContextPtr &	ctx
	)

static

Evaluate a query using a goal-driven reasoner.

Parameters

reasoner	the reasoner to use.
literals	the query to evaluate.
ctx	the query context.

Returns: a buffer that can be used to retrieve the results of the query.

◆ findDefiningReasoner() [1/2]

std::vector< DefiningReasoner > ReasonerManager::findDefiningReasoner ( const PredicateIndicator & indicator ) const

Parameters

indicator a predicate indicator.

Returns: the reasoners that define the given relation.

Definition at line 48 of file ReasonerManager.cpp.

                                                                                                            {
     std::vector<DefiningReasoner> reasoners;
  
     if (indicator.arity() == 1) {
         // unary predicates can be RDF class expressions.
         // in this case we need to check the class hierarchy.
         auto rdfClass = kb_->vocabulary()->getDefinedClass(indicator.functor()->stringForm());
         if (rdfClass) {
             for (auto &x: goalDriven_) {
                 for (auto &definedClassIndicator : x.second->definedClasses()) {
                     auto definedClass = kb_->vocabulary()->getDefinedClass(definedClassIndicator.functor()->stringForm());
                     if(definedClass && definedClass->isSubClassOf(rdfClass)) {
                         reasoners.push_back({x.second, definedClass->iriAtom()});
                         break;
                     }
                 }
             }
             return reasoners;
         }
     }
  
     if (indicator.arity() == 2) {
         // binary predicates can be RDF properties.
         // in this case we need to check the property hierarchy.
         auto rdfProperty = kb_->vocabulary()->getDefinedProperty(indicator.functor()->stringForm());
         if (rdfProperty) {
             for (auto &x: goalDriven_) {
                 for (auto &definedPropertyIndicator : x.second->definedRelations()) {
                     auto definedProperty = kb_->vocabulary()->getDefinedProperty(definedPropertyIndicator.functor()->stringForm());
                     if ( definedProperty && definedProperty->isSubPropertyOf(rdfProperty) ) {
                         reasoners.push_back({x.second, definedProperty->iriAtom()});
                         break;
                     }
                 }
             }
             return reasoners;
         }
     }
  
     for (auto &x: goalDriven_) {
         if (x.second->isRelationDefined(indicator) || (indicator.arity()==1 && x.second->isClassDefined(indicator.functor()->stringForm()))) {
             reasoners.push_back({x.second, indicator.functor()});
         }
     }
     return reasoners;
 }

◆ findDefiningReasoner() [2/2]

std::vector<DefiningReasoner> knowrob::ReasonerManager::findDefiningReasoner ( const PredicateIndicator & indicator ) const

Parameters

indicator a predicate indicator.

Returns: the reasoners that define the given relation.

◆ getReasonerStorage() [1/2]

std::shared_ptr< Storage > ReasonerManager::getReasonerStorage ( const std::shared_ptr< NamedReasoner > & reasoner )

Return the backend associated with a reasoner if any.

Parameters

reasoner a defined reasoner.

Returns: a backend or a null reference.

Definition at line 39 of file ReasonerManager.cpp.

                                                                                                        {
     auto it = reasonerBackends_.find(reasoner->name());
     if (it != reasonerBackends_.end()) {
         return it->second;
     } else {
         return nullptr;
     }
 }

◆ getReasonerStorage() [2/2]

std::shared_ptr<Storage> knowrob::ReasonerManager::getReasonerStorage ( const std::shared_ptr< NamedReasoner > & reasoner )

Return the backend associated with a reasoner if any.

Parameters

reasoner a defined reasoner.

Returns: a backend or a null reference.

◆ goalDriven() [1/2]

auto& knowrob::ReasonerManager::goalDriven ( ) const

inline

Returns: the goal-driven reasoners defined by this manager.

Definition at line 43 of file ReasonerManager.h.

43 { return goalDriven_; }

◆ goalDriven() [2/2]

auto& knowrob::ReasonerManager::goalDriven ( ) const

inline

Returns: the goal-driven reasoners defined by this manager.

Definition at line 43 of file ReasonerManager.h.

43 { return goalDriven_; }

◆ kb() [1/2]

auto knowrob::ReasonerManager::kb ( ) const

inline

Returns: the knowledge base associated with this manager.

Definition at line 33 of file ReasonerManager.h.

33 { return kb_; }

◆ kb() [2/2]

auto knowrob::ReasonerManager::kb ( ) const

inline

Returns: the knowledge base associated with this manager.

Definition at line 33 of file ReasonerManager.h.

33 { return kb_; }

◆ loadPlugin() [1/2]

std::shared_ptr< NamedReasoner > ReasonerManager::loadPlugin ( const boost::property_tree::ptree & config )

overridevirtual

Load a new plugin instance into the plugin manager. The type of the plugin is determined based on either the value of "type", "lib" or "module" in the property tree root. The tree is further used to generate a plugin configuration. Plugin factories for libraries are created on the fly, the ones for built-in plugin types need to be added to the plugin manager before.

Parameters

config a property tree holding a plugin configuration

Implements knowrob::PluginManager< Reasoner >.

Definition at line 95 of file ReasonerManager.cpp.

                                                                                               {
     // get a reasoner factory
     std::shared_ptr<ReasonerFactory> factory = findFactory(config);
     // make sure factory was found above
     if (!factory) throw ReasonerError("failed to load a reasoner.");
     // create a reasoner id, or use name property
     std::string reasonerID = getPluginID(factory, config);
     KB_INFO("Using reasoner `{}` with type `{}`.", reasonerID, factory->name());
  
     // create a new reasoner instance
     auto reasoner = factory->create(reasonerID);
     // reasoner need to have a reference to the reasoner manager such that
     // predicates can be defined that interact with the KB
     reasoner->value()->setReasonerManager(this);
     reasoner->value()->setReasonerName(reasonerID);
  
     auto backendName = config.get_optional<std::string>("data-backend");
     if (backendName.has_value()) {
         auto definedBackend = backendManager_->getPluginWithID(backendName.value());
         if (definedBackend) {
             setReasonerStorage(reasoner, definedBackend->value());
         } else {
             throw ReasonerError("Reasoner `{}` refers to unknown data-backend `{}`.", reasonerID, backendName.value());
         }
     } else {
         // check if reasoner implements DataBackend interface
         auto backend = std::dynamic_pointer_cast<Storage>(reasoner->value());
         if (backend) {
             setReasonerStorage(reasoner, backend);
             backendManager_->addPlugin(reasonerID, reasoner->language(), backend);
         } else {
             throw ReasonerError("Reasoner `{}` has no 'data-backend' configured.", reasonerID);
         }
     }
     auto definedReasoner = addPlugin(reasonerID, reasoner->language(), reasoner->value());
  
     PropertyTree pluginConfig(std::make_shared<boost::property_tree::ptree>(config));
     if (!initializeReasoner(reasoner, pluginConfig)) {
         KB_WARN("Reasoner `{}` failed to loadConfig.", reasonerID);
     } else {
         // load the reasoner-specific data sources.
         for (auto &dataSource: pluginConfig.dataSources()) {
             if (!reasoner->value()->loadDataSource(dataSource)) {
                 KB_WARN("Reasoner `{}` failed to load data source {}.", reasonerID, dataSource->uri());
             }
         }
     }
  
     return definedReasoner;
 }

◆ loadPlugin() [2/2]

std::shared_ptr<NamedReasoner> knowrob::ReasonerManager::loadPlugin ( const boost::property_tree::ptree & config )

overridevirtual

Load a new plugin instance into the plugin manager. The type of the plugin is determined based on either the value of "type", "lib" or "module" in the property tree root. The tree is further used to generate a plugin configuration. Plugin factories for libraries are created on the fly, the ones for built-in plugin types need to be added to the plugin manager before.

Parameters

config a property tree holding a plugin configuration

Implements knowrob::PluginManager< Reasoner >.

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/ReasonerManager.h
src/reasoner/ReasonerManager.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ReasonerManager() [1/2]

◆ ~ReasonerManager() [1/2]

◆ ReasonerManager() [2/2]

◆ ~ReasonerManager() [2/2]

Member Function Documentation

◆ addPlugin() [1/2]

◆ addPlugin() [2/2]

◆ backendManager() [1/2]

◆ backendManager() [2/2]

◆ dataDriven() [1/2]

◆ dataDriven() [2/2]

◆ evaluateQuery() [1/2]

◆ evaluateQuery() [2/2]

◆ findDefiningReasoner() [1/2]

◆ findDefiningReasoner() [2/2]

◆ getReasonerStorage() [1/2]

◆ getReasonerStorage() [2/2]

◆ goalDriven() [1/2]

◆ goalDriven() [2/2]

◆ kb() [1/2]

◆ kb() [2/2]

◆ loadPlugin() [1/2]

◆ loadPlugin() [2/2]