knowrob::KnowledgeBase Class Reference

#include <KnowledgeBase.h>

Inheritance diagram for knowrob::KnowledgeBase:

Collaboration diagram for knowrob::KnowledgeBase:

Public Member Functions
	~KnowledgeBase ()
void	init ()
void	loadCommon ()
bool	loadDataSource (const DataSourcePtr &source)
auto &	vocabulary () const
auto &	edb () const
auto &	reasonerManager () const
auto &	backendManager () const
QueryableBackendPtr	getBackendForQuery () const
TokenBufferPtr	submitQuery (const ConjunctiveQueryPtr &conjunctiveQuery)
TokenBufferPtr	submitQuery (const FirstOrderLiteralPtr &query, const QueryContextPtr &ctx)
TokenBufferPtr	submitQuery (const FormulaPtr &query, const QueryContextPtr &ctx)
ObserverPtr	observe (const GraphQueryPtr &query, const BindingsHandler &callback)
void	synchronizeObservers ()
bool	insertOne (const Triple &triple)
bool	insertAll (const TripleContainerPtr &triples)
bool	insertAll (const std::vector< TriplePtr > &triples)
bool	removeOne (const Triple &triple)
bool	removeAll (const TripleContainerPtr &triples)
bool	removeAll (const std::vector< TriplePtr > &triples)
bool	removeAllWithOrigin (std::string_view origin)
void	setDefaultGraph (std::string_view origin)
	~KnowledgeBase ()
void	init ()
void	loadCommon ()
bool	loadDataSource (const DataSourcePtr &source)
auto &	vocabulary () const
auto &	edb () const
auto &	reasonerManager () const
auto &	backendManager () const
QueryableBackendPtr	getBackendForQuery () const
TokenBufferPtr	submitQuery (const ConjunctiveQueryPtr &conjunctiveQuery)
TokenBufferPtr	submitQuery (const FirstOrderLiteralPtr &query, const QueryContextPtr &ctx)
TokenBufferPtr	submitQuery (const FormulaPtr &query, const QueryContextPtr &ctx)
ObserverPtr	observe (const GraphQueryPtr &query, const BindingsHandler &callback)
void	synchronizeObservers ()
bool	insertOne (const Triple &triple)
bool	insertAll (const TripleContainerPtr &triples)
bool	insertAll (const std::vector< TriplePtr > &triples)
bool	removeOne (const Triple &triple)
bool	removeAll (const TripleContainerPtr &triples)
bool	removeAll (const std::vector< TriplePtr > &triples)
bool	removeAllWithOrigin (std::string_view origin)
void	setDefaultGraph (std::string_view origin)

Static Public Member Functions
static std::shared_ptr< KnowledgeBase >	create (const boost::property_tree::ptree &config)
static std::shared_ptr< KnowledgeBase >	create (std::string_view config)
static std::shared_ptr< KnowledgeBase >	create ()
static std::shared_ptr< KnowledgeBase >	create (const boost::property_tree::ptree &config)
static std::shared_ptr< KnowledgeBase >	create (std::string_view config)
static std::shared_ptr< KnowledgeBase >	create ()

Protected Member Functions
	KnowledgeBase (const boost::property_tree::ptree &config)
	KnowledgeBase (std::string_view config)
	KnowledgeBase ()
void	configure (const boost::property_tree::ptree &config)
void	configureDataSources (const boost::property_tree::ptree &config)
void	configureBackends (const boost::property_tree::ptree &config)
void	configureReasoner (const boost::property_tree::ptree &config)
void	initVocabulary ()
void	addToVocabulary (const TriplePtr &triple)
void	initBackends ()
void	synchronizeBackends ()
std::shared_ptr< NamedBackend >	findSourceBackend (const Triple &triple)
void	startReasoner ()
void	stopReasoner ()
std::vector< std::shared_ptr< NamedBackend > >	prepareLoad (std::string_view origin, std::string_view newVersion) const
void	finishLoad (const std::shared_ptr< OntologySource > &source, std::string_view origin, std::string_view newVersion)
bool	loadNonOntologySource (const DataSourcePtr &source) const
bool	loadOntologySource (const std::shared_ptr< OntologySource > &source)
std::optional< std::string >	getVersionOfOrigin (const std::shared_ptr< NamedBackend > &definedBackend, std::string_view origin) const
	KnowledgeBase (const boost::property_tree::ptree &config)
	KnowledgeBase (std::string_view config)
	KnowledgeBase ()
void	configure (const boost::property_tree::ptree &config)
void	configureDataSources (const boost::property_tree::ptree &config)
void	configureBackends (const boost::property_tree::ptree &config)
void	configureReasoner (const boost::property_tree::ptree &config)
void	initVocabulary ()
void	addToVocabulary (const TriplePtr &triple)
void	initBackends ()
void	synchronizeBackends ()
std::shared_ptr< NamedBackend >	findSourceBackend (const Triple &triple)
void	startReasoner ()
void	stopReasoner ()
std::vector< std::shared_ptr< NamedBackend > >	prepareLoad (std::string_view origin, std::string_view newVersion) const
void	finishLoad (const std::shared_ptr< OntologySource > &source, std::string_view origin, std::string_view newVersion)
bool	loadNonOntologySource (const DataSourcePtr &source) const
bool	loadOntologySource (const std::shared_ptr< OntologySource > &source)
std::optional< std::string >	getVersionOfOrigin (const std::shared_ptr< NamedBackend > &definedBackend, std::string_view origin) const

Static Protected Member Functions
static void	configurePrefixes (const boost::property_tree::ptree &config)
static void	configurePrefixes (const boost::property_tree::ptree &config)

Protected Attributes
std::shared_ptr< StorageInterface >	edb_
std::shared_ptr< ReasonerManager >	reasonerManager_
std::shared_ptr< StorageManager >	backendManager_
std::shared_ptr< Vocabulary >	vocabulary_
std::shared_ptr< ObserverManager >	observerManager_
bool	isInitialized_

Detailed Description

The main interface to the knowledge base system implementing its 'tell' and 'ask' interface. Note that it is perfectly fine to have multiple KnowledgeBase instances in one application.

Definition at line 32 of file KnowledgeBase.h.

Constructor & Destructor Documentation

~KnowledgeBase() [1/2]

KnowledgeBase::~KnowledgeBase

(

)

Definition at line 64 of file KnowledgeBase.cpp.

                              {
    stopReasoner();
    if(observerManager_) {
        observerManager_->stop();
        observerManager_ = nullptr;
    }
    edb_ = nullptr;
    backendManager_ = nullptr;
    reasonerManager_ = nullptr;
    vocabulary_ = nullptr;
}

KnowledgeBase() [1/6]

KnowledgeBase::KnowledgeBase ( const boost::property_tree::ptree &  config )

explicitprotected

Definition at line 46 of file KnowledgeBase.cpp.

                                                                  : KnowledgeBase() {
    configure(config);
    init();
}

KnowledgeBase() [2/6]

KnowledgeBase::KnowledgeBase ( std::string_view  config )

explicitprotected

Definition at line 51 of file KnowledgeBase.cpp.

                                                      : KnowledgeBase() {
    boost::property_tree::ptree config;
    // Test if string is a JSON string or a file path
    if (configFile.find_first_of('{') == 0) {
        std::istringstream json_stream(configFile.data());
        boost::property_tree::read_json(json_stream, config);
    } else {
        boost::property_tree::read_json(URI::resolve(configFile), config);
    }
    configure(config);
    init();
}

KnowledgeBase() [3/6]

KnowledgeBase::KnowledgeBase ( )

explicitprotected

Definition at line 36 of file KnowledgeBase.cpp.

        : isInitialized_(false) {
    vocabulary_ = std::make_shared<Vocabulary>();
    // use "system" as default origin until initialization completed
    vocabulary_->importHierarchy()->setDefaultGraph(ImportHierarchy::ORIGIN_SYSTEM);
    backendManager_ = std::make_shared<StorageManager>(vocabulary_);
    reasonerManager_ = std::make_shared<ReasonerManager>(this, backendManager_);
    edb_ = std::make_shared<StorageInterface>(backendManager_);
}

~KnowledgeBase() [2/2]

knowrob::KnowledgeBase::~KnowledgeBase

(

)

KnowledgeBase() [4/6]

knowrob::KnowledgeBase::KnowledgeBase ( const boost::property_tree::ptree &  config )

explicitprotected

KnowledgeBase() [5/6]

knowrob::KnowledgeBase::KnowledgeBase ( std::string_view  config )

explicitprotected

KnowledgeBase() [6/6]

knowrob::KnowledgeBase::KnowledgeBase ( )

explicitprotected

Member Function Documentation

addToVocabulary() [1/2]

void KnowledgeBase::addToVocabulary ( const TriplePtr &  triple )

protected

Definition at line 250 of file KnowledgeBase.cpp.

                                                           {
    auto propertyAtom = IRIAtom::Tabled(triple->predicate());
    // handle rdf:type assertions
    if (propertyAtom.get() == rdf::type.get()) {
        vocabulary_->addResourceType(triple->subject(), triple->valueAsString());
        vocabulary_->increaseFrequency(rdf::type->stringForm());
    }
    // handle rdfs::subClassOf assertions
    else if (propertyAtom.get() == rdfs::subClassOf.get()) {
        vocabulary_->addSubClassOf(triple->subject(), triple->valueAsString(), triple->graph());
        vocabulary_->increaseFrequency(rdfs::subClassOf->stringForm());
    }
    // handle rdfs::subPropertyOf assertions
    else if (propertyAtom.get() == rdfs::subPropertyOf.get()) {
        vocabulary_->addSubPropertyOf(triple->subject(), triple->valueAsString(), triple->graph());
        vocabulary_->increaseFrequency(rdfs::subPropertyOf->stringForm());
    }
    // handle owl::inverseOf assertions
    else if (propertyAtom.get() == owl::inverseOf.get()) {
        vocabulary_->setInverseOf(triple->subject(), triple->valueAsString());
        vocabulary_->increaseFrequency(owl::inverseOf->stringForm());
    } else {
        vocabulary_->defineProperty(propertyAtom);
        vocabulary_->increaseFrequency(propertyAtom->stringForm());
    }
    // TODO: need to add special handling for reified relations here?
}

addToVocabulary() [2/2]

void knowrob::KnowledgeBase::addToVocabulary ( const TriplePtr &  triple )

protected

backendManager() [1/2]

auto& knowrob::KnowledgeBase::backendManager ( ) const

inline

Returns

the storage manager of this knowledge base

Definition at line 82 of file KnowledgeBase.h.

{ return backendManager_; }

backendManager() [2/2]

auto& knowrob::KnowledgeBase::backendManager ( ) const

inline

Returns

the storage manager of this knowledge base

Definition at line 82 of file KnowledgeBase.h.

{ return backendManager_; }

configure() [1/2]

void KnowledgeBase::configure ( const boost::property_tree::ptree &  config )

protected

Definition at line 278 of file KnowledgeBase.cpp.

                                                                   {
    configurePrefixes(config);
    // initialize data backends from configuration
    configureBackends(config);
    // share vocabulary and import hierarchy with backends
    initBackends();
    // load common ontologies
    loadCommon();
    // load the "global" data sources.
    // these are data sources that are loaded into all backends, however
    // the backends may decide to ignore some of the data sources.
    configureDataSources(config);
    // load reasoners from configuration
    configureReasoner(config);
}

configure() [2/2]

void knowrob::KnowledgeBase::configure ( const boost::property_tree::ptree &  config )

protected

configureBackends() [1/2]

void KnowledgeBase::configureBackends ( const boost::property_tree::ptree &  config )

protected

Definition at line 311 of file KnowledgeBase.cpp.

                                                                           {
    auto backendList = config.get_child_optional(KB_SETTING_DATA_BACKENDS);
    if (backendList) {
        for (const auto &pair: backendList.value()) {
            KB_LOGGED_TRY_CATCH(pair.first, "load", { backendManager_->loadPlugin(pair.second); });
        }
    } else {
        KB_ERROR("configuration has no 'backends' key.");
    }
}

configureBackends() [2/2]

void knowrob::KnowledgeBase::configureBackends ( const boost::property_tree::ptree &  config )

protected

configureDataSources() [1/2]

void KnowledgeBase::configureDataSources ( const boost::property_tree::ptree &  config )

protected

Definition at line 522 of file KnowledgeBase.cpp.

                                                                              {
    auto dataSourcesList = config.get_child_optional(KB_SETTING_DATA_SOURCES);
    if (!dataSourcesList) return;
 
    for (const auto &pair: dataSourcesList.value()) {
        auto &subtree = pair.second;
        auto dataSource = DataSource::create(vocabulary_, subtree);
        if (!dataSource) {
            KB_ERROR("Failed to create data source \"{}\".", pair.first);
            continue;
        }
        bool has_error;
        auto transformationConfig = config.get_child_optional(KB_SETTING_DATA_TRANSFORMATION);
        if (transformationConfig) {
            if (dataSource->dataSourceType() != DataSourceType::ONTOLOGY) {
                KB_ERROR("Transformations can only be applied on ontology data sources.");
                continue;
            }
            auto ontology = std::static_pointer_cast<OntologySource>(dataSource);
            // apply a transformation to the data source if "transformation" key is present
            auto transformation = GraphTransformation::create(transformationConfig.value());
            auto transformed = std::make_shared<TransformedOntology>(URI(ontology->uri()), ontology->format());
            transformation->apply(*ontology, [&transformed](const TripleContainerPtr &triples) {
                transformed->storage()->insertAll(triples);
            });
            has_error = !loadDataSource(transformed);
        } else {
            has_error = !loadDataSource(dataSource);
        }
        if (has_error) {
            KB_ERROR("Failed to load data source from \"{}\".", dataSource->uri());
        }
    }
}

configureDataSources() [2/2]

void knowrob::KnowledgeBase::configureDataSources ( const boost::property_tree::ptree &  config )

protected

configurePrefixes() [1/2]

void KnowledgeBase::configurePrefixes ( const boost::property_tree::ptree &  config )

staticprotected

Definition at line 294 of file KnowledgeBase.cpp.

                                                                           {
    auto semwebTree = config.get_child_optional(KB_SETTING_SEMWEB);
    if (semwebTree) {
        // load RDF URI aliases
        auto prefixesList = semwebTree.value().get_child_optional(KB_SETTING_PREFIXES);
        for (const auto &pair: prefixesList.value()) {
            auto alias = pair.second.get(KB_SETTING_PREFIX_ALIAS, "");
            auto uri = pair.second.get(KB_SETTING_PREFIX_URI, "");
            if (!alias.empty() && !uri.empty()) {
                PrefixRegistry::registerPrefix(alias, uri);
            } else {
                KB_WARN("Invalid entry in semantic-web::prefixes, 'alias' and 'uri' must be defined.");
            }
        }
    }
}

configurePrefixes() [2/2]

static void knowrob::KnowledgeBase::configurePrefixes ( const boost::property_tree::ptree &  config )

staticprotected

configureReasoner() [1/2]

void KnowledgeBase::configureReasoner ( const boost::property_tree::ptree &  config )

protected

Definition at line 322 of file KnowledgeBase.cpp.

                                                                           {
    auto reasonerList = config.get_child_optional(KB_SETTING_REASONER);
    if (reasonerList) {
        for (const auto &pair: reasonerList.value()) {
            KB_LOGGED_TRY_CATCH(pair.first, "load", {
                auto definedReasoner = reasonerManager_->loadPlugin(pair.second);
                // if reasoner implements DataBackend class, add it to the backend manager
                auto reasonerBackend = std::dynamic_pointer_cast<Storage>(definedReasoner->value());
                if (reasonerBackend) {
                    backendManager_->addPlugin(definedReasoner->name(), definedReasoner->language(), reasonerBackend);
                }
            });
        }
    } else {
        KB_ERROR("configuration has no 'reasoner' key.");
    }
}

configureReasoner() [2/2]

void knowrob::KnowledgeBase::configureReasoner ( const boost::property_tree::ptree &  config )

protected

create() [1/6]

std::shared_ptr< KnowledgeBase > KnowledgeBase::create ( )

static

Create a new KnowledgeBase instance.

Definition at line 84 of file KnowledgeBase.cpp.

                                                   {
    return std::shared_ptr<KnowledgeBase>(new KnowledgeBase());
}

create() [2/6]

static std::shared_ptr<KnowledgeBase> knowrob::KnowledgeBase::create ( )

static

Create a new KnowledgeBase instance.

create() [3/6]

std::shared_ptr< KnowledgeBase > KnowledgeBase::create ( const boost::property_tree::ptree &  config )

static

Create a new KnowledgeBase instance.

Parameters

config

a property tree used to configure this.

Definition at line 76 of file KnowledgeBase.cpp.

                                                                                        {
    return std::shared_ptr<KnowledgeBase>(new KnowledgeBase(config));
}

create() [4/6]

static std::shared_ptr<KnowledgeBase> knowrob::KnowledgeBase::create ( const boost::property_tree::ptree &  config )

static

Create a new KnowledgeBase instance.

Parameters

config

a property tree used to configure this.

create() [5/6]

std::shared_ptr< KnowledgeBase > KnowledgeBase::create ( std::string_view  config )

static

Create a new KnowledgeBase instance.

Parameters

config

a JSON string used to configure this or the path to a JSON file.

Definition at line 80 of file KnowledgeBase.cpp.

                                                                        {
    return std::shared_ptr<KnowledgeBase>(new KnowledgeBase(config));
}

create() [6/6]

static std::shared_ptr<KnowledgeBase> knowrob::KnowledgeBase::create ( std::string_view  config )

static

Create a new KnowledgeBase instance.

Parameters

config

a JSON string used to configure this or the path to a JSON file.

edb() [1/2]

auto& knowrob::KnowledgeBase::edb ( ) const

inline

Returns

the storage interface of this knowledge base

Definition at line 72 of file KnowledgeBase.h.

{ return edb_; }

edb() [2/2]

auto& knowrob::KnowledgeBase::edb ( ) const

inline

Returns

the storage interface of this knowledge base

Definition at line 72 of file KnowledgeBase.h.

{ return edb_; }

findSourceBackend() [1/2]

std::shared_ptr< NamedBackend > KnowledgeBase::findSourceBackend ( const Triple &  triple )

protected

Definition at line 500 of file KnowledgeBase.cpp.

                                                                                 {
    if (!triple.graph()) return {};
 
    auto definedBackend_withID = backendManager_->getPluginWithID(triple.graph().value());
    if (definedBackend_withID) return definedBackend_withID;
 
    auto definedReasoner = reasonerManager_->getPluginWithID(triple.graph().value());
    if (definedReasoner) {
        auto reasonerBackend = reasonerManager_->getReasonerStorage(definedReasoner);
        if (reasonerBackend) {
            for (auto &it: backendManager_->plugins()) {
                auto &definedBackend_ofReasoner = it.second;
                if (definedBackend_ofReasoner->value() == reasonerBackend) {
                    return definedBackend_ofReasoner;
                }
            }
        }
    }
 
    return {};
}

findSourceBackend() [2/2]

std::shared_ptr<NamedBackend> knowrob::KnowledgeBase::findSourceBackend ( const Triple &  triple )

protected

finishLoad() [1/2]

void KnowledgeBase::finishLoad ( const std::shared_ptr< OntologySource > &  source, std::string_view  origin, std::string_view  newVersion  )

protected

Definition at line 600 of file KnowledgeBase.cpp.

                                                          {
    // update the version triple
    for (auto &it: backendManager_->plugins()) {
        it.second->value()->setVersionOfOrigin(origin, newVersion);
    }
    for (auto &it: backendManager_->persistent()) {
        auto persistentBackend = it.second;
        persistentBackend->setVersionOfOrigin(origin, newVersion);
    }
 
    // add direct import
    if (source->parentOrigin().has_value()) {
        vocabulary_->importHierarchy()->addDirectImport(source->parentOrigin().value(), origin);
    } else {
        vocabulary_->importHierarchy()->addDirectImport(vocabulary_->importHierarchy()->defaultGraph(), origin);
    }
}

finishLoad() [2/2]

void knowrob::KnowledgeBase::finishLoad ( const std::shared_ptr< OntologySource > &  source, std::string_view  origin, std::string_view  newVersion  )

protected

getBackendForQuery() [1/2]

QueryableBackendPtr KnowledgeBase::getBackendForQuery

(

)

const

Returns

the default graph of this knowledge base

Definition at line 374 of file KnowledgeBase.cpp.

                                                            {
    auto &queryable = backendManager_->queryable();
    if (queryable.empty()) {
        KB_WARN("No queryable backends available.");
        return nullptr;
    } else {
        return queryable.begin()->second;
    }
}

getBackendForQuery() [2/2]

QueryableBackendPtr knowrob::KnowledgeBase::getBackendForQuery

(

)

const

Returns

the default graph of this knowledge base

getVersionOfOrigin() [1/2]

std::optional< std::string > KnowledgeBase::getVersionOfOrigin ( const std::shared_ptr< NamedBackend > &  definedBackend, std::string_view  origin  ) const

protected

Definition at line 567 of file KnowledgeBase.cpp.

                                                                                        {
    // check if the origin was loaded before in this session
    auto runtimeVersion = definedBackend->value()->getVersionOfOrigin(origin);
    if (runtimeVersion) return runtimeVersion;
    // otherwise check if the backend is persistent and if so, ask the persistent backend
    auto persistentBackend = backendManager_->persistent().find(definedBackend->name());
    if (persistentBackend != backendManager_->persistent().end()) {
        return persistentBackend->second->getVersionOfOrigin(origin);
    }
    return {};
}

getVersionOfOrigin() [2/2]

std::optional<std::string> knowrob::KnowledgeBase::getVersionOfOrigin ( const std::shared_ptr< NamedBackend > &  definedBackend, std::string_view  origin  ) const

protected

init() [1/2]

void KnowledgeBase::init

(

)

Definition at line 88 of file KnowledgeBase.cpp.

                         {
    isInitialized_ = true;
    vocabulary_->importHierarchy()->setDefaultGraph(ImportHierarchy::ORIGIN_USER);
    initBackends();
    synchronizeBackends();
    initVocabulary();
 
    observerManager_ = std::make_shared<ObserverManager>(getBackendForQuery());
    startReasoner();
}

init() [2/2]

void knowrob::KnowledgeBase::init

(

)

initBackends() [1/2]

void KnowledgeBase::initBackends ( )

protected

Definition at line 99 of file KnowledgeBase.cpp.

                                 {
    for (auto &pair: backendManager_->plugins()) {
        auto definedBackend = pair.second;
        definedBackend->value()->setVocabulary(vocabulary_);
    }
}

initBackends() [2/2]

void knowrob::KnowledgeBase::initBackends ( )

protected

initVocabulary() [1/2]

void KnowledgeBase::initVocabulary ( )

protected

Definition at line 197 of file KnowledgeBase.cpp.

                                   {
    auto v_s = std::make_shared<Variable>("?s");
    auto v_o = std::make_shared<Variable>("?o");
 
    for (auto &it: backendManager_->persistent()) {
        auto backend = it.second;
 
        // initialize the import hierarchy
        for (auto &origin: backend->getOrigins()) {
            vocabulary_->importHierarchy()->addDirectImport(vocabulary_->importHierarchy()->ORIGIN_SYSTEM,
                                                            origin->value());
        }
 
        // iterate over all rdf:type assertions and add them to the vocabulary
        backend->match(TriplePattern(v_s, rdf::type, v_o),
                       [this](const TriplePtr &triple) {
                           vocabulary_->addResourceType(triple->subject(), triple->valueAsString());
                           vocabulary_->increaseFrequency(rdf::type->stringForm());
                       });
        // iterate over all rdfs::subClassOf assertions and add them to the vocabulary
        backend->match(TriplePattern(v_s, rdfs::subClassOf, v_o),
                       [this](const TriplePtr &triple) {
                           vocabulary_->addSubClassOf(triple->subject(), triple->valueAsString(), triple->graph());
                           vocabulary_->increaseFrequency(rdfs::subClassOf->stringForm());
                       });
        // iterate over all rdfs::subPropertyOf assertions and add them to the vocabulary
        backend->match(TriplePattern(v_s, rdfs::subPropertyOf, v_o),
                       [this](const TriplePtr &triple) {
                           vocabulary_->addSubPropertyOf(triple->subject(), triple->valueAsString(), triple->graph());
                           vocabulary_->increaseFrequency(rdfs::subPropertyOf->stringForm());
                       });
        // iterate over all owl::inverseOf assertions and add them to the vocabulary
        backend->match(TriplePattern(v_s, owl::inverseOf, v_o),
                       [this](const TriplePtr &triple) {
                           vocabulary_->setInverseOf(triple->subject(), triple->valueAsString());
                           vocabulary_->increaseFrequency(owl::inverseOf->stringForm());
                       });
 
        // query number of assertions of each property/class.
        // this is useful information for optimizing the query planner.
        std::vector<semweb::PropertyPtr> reifiedProperties;
        backend->count([this, &reifiedProperties](std::string_view resource, uint64_t count) {
            // special handling for reified relations: they are concepts, but do also increase the relation counter
            auto reifiedProperty = vocabulary_->getDefinedReification(resource);
            if (reifiedProperty) reifiedProperties.push_back(reifiedProperty);
            vocabulary_->setFrequency(resource, count);
        });
        for (auto &p: reifiedProperties) {
            vocabulary_->increaseFrequency(p->iri());
        }
    }
}

initVocabulary() [2/2]

void knowrob::KnowledgeBase::initVocabulary ( )

protected

insertAll() [1/4]

bool KnowledgeBase::insertAll

(

const std::vector< TriplePtr > &

triples

)

Insert a collection of triples into the knowledge base.

Parameters

triples

the triples to insert

Returns

true if the triples were inserted successfully

Definition at line 487 of file KnowledgeBase.cpp.

                                                                 {
    // Note: insertAll blocks until the triples are inserted, so it is safe to use the triples vector as a pointer.
    return insertAll(std::make_shared<ProxyTripleContainer>(&triples));
}

insertAll() [2/4]

bool knowrob::KnowledgeBase::insertAll

(

const std::vector< TriplePtr > &

triples

)

Insert a collection of triples into the knowledge base.

Parameters

triples

the triples to insert

Returns

true if the triples were inserted successfully

insertAll() [3/4]

bool KnowledgeBase::insertAll

(

const TripleContainerPtr &

triples

)

Insert a collection of triples into the knowledge base.

Parameters

triples

the triples to insert

Returns

true if the triples were inserted successfully

Definition at line 434 of file KnowledgeBase.cpp.

                                                               {
    auto sourceBackend = findSourceBackend(**triples->begin());
    auto transaction = edb_->createTransaction(
            getBackendForQuery(),
            StorageInterface::Insert,
            StorageInterface::Excluding,
            {sourceBackend});
    if (transaction->commit(triples)) {
        // update the vocabulary with the new triples
        for (auto &triple: *triples) {
            addToVocabulary(triple);
        }
        observerManager_->insert(triples);
        return true;
    } else {
        return false;
    }
}

insertAll() [4/4]

bool knowrob::KnowledgeBase::insertAll

(

const TripleContainerPtr &

triples

)

Insert a collection of triples into the knowledge base.

Parameters

triples

the triples to insert

Returns

true if the triples were inserted successfully

insertOne() [1/2]

bool KnowledgeBase::insertOne

(

const Triple &

triple

)

Insert a single triple into the knowledge base.

Parameters

triple

the triple to insert

Returns

true if the triple was inserted successfully

Definition at line 415 of file KnowledgeBase.cpp.

                                                  {
    auto sourceBackend = findSourceBackend(triple);
    auto transaction = edb_->createTransaction(
            getBackendForQuery(),
            StorageInterface::Insert,
            StorageInterface::Excluding,
            {sourceBackend});
    if (transaction->commit(triple)) {
        auto tripleCopy = new TripleCopy(triple);
        std::vector<TriplePtr> triples;
        triples.emplace_back(tripleCopy);
        auto container = std::make_shared<ProxyTripleContainer>(triples);
        observerManager_->insert(container);
        return true;
    } else {
        return false;
    }
}

insertOne() [2/2]

bool knowrob::KnowledgeBase::insertOne

(

const Triple &

triple

)

Insert a single triple into the knowledge base.

Parameters

triple

the triple to insert

Returns

true if the triple was inserted successfully

loadCommon() [1/2]

void KnowledgeBase::loadCommon

(

)

Definition at line 340 of file KnowledgeBase.cpp.

                               {
    for (auto &ontoPath: {"owl/rdf-schema.xml", "owl/owl.rdf"}) {
        loadDataSource(std::make_shared<OntologyFile>(vocabulary_, URI(ontoPath), "rdf-xml"));
    }
}

loadCommon() [2/2]

void knowrob::KnowledgeBase::loadCommon

(

)

loadDataSource() [1/2]

bool KnowledgeBase::loadDataSource

(

const DataSourcePtr &

source

)

Load a data source into the knowledge base, possibly loading it into multiple backends.

Parameters

source

the data source to load

Returns

true if the data source was loaded successfully

Definition at line 557 of file KnowledgeBase.cpp.

                                                              {
    switch (source->dataSourceType()) {
        case DataSourceType::ONTOLOGY:
            return loadOntologySource(std::static_pointer_cast<OntologySource>(source));
        case DataSourceType::UNSPECIFIED:
            return loadNonOntologySource(source);
    }
    return false;
}

loadDataSource() [2/2]

bool knowrob::KnowledgeBase::loadDataSource

(

const DataSourcePtr &

source

)

Load a data source into the knowledge base, possibly loading it into multiple backends.

Parameters

source

the data source to load

Returns

true if the data source was loaded successfully

loadNonOntologySource() [1/2]

bool KnowledgeBase::loadNonOntologySource ( const DataSourcePtr &  source ) const

protected

Definition at line 658 of file KnowledgeBase.cpp.

                                                                           {
    bool hasHandler = false;
    bool allSucceeded = true;
 
    for (auto &kg_pair: backendManager_->plugins()) {
        auto backend = kg_pair.second->value();
        if (backend->hasDataHandler(source)) {
            if (!backend->loadDataSource(source)) {
                allSucceeded = false;
                KB_WARN("backend '{}' failed to load data source '{}'", kg_pair.first, source->uri());
            }
            hasHandler = true;
        }
    }
 
    if (!hasHandler) {
        KB_WARN("no data handler for data source format '{}'", source->format());
    }
 
    return hasHandler && allSucceeded;
}

loadNonOntologySource() [2/2]

bool knowrob::KnowledgeBase::loadNonOntologySource ( const DataSourcePtr &  source ) const

protected

loadOntologySource() [1/2]

bool KnowledgeBase::loadOntologySource ( const std::shared_ptr< OntologySource > &  source )

protected

Definition at line 619 of file KnowledgeBase.cpp.

                                                                                  { // NOLINT(misc-no-recursion)
    auto uri = URI::resolve(source->uri());
    // Some ontologies may encode version in the URI which we try to extract
    // below. Otherwise, we just use the current day as version causing a re-load every day.
    auto newVersion = DataSource::getVersionFromURI(uri);
 
    // get all backends that do not have the data loaded yet
    auto backendsToLoad = prepareLoad(source->origin(), newVersion);
    if (backendsToLoad.empty()) {
        // data is already loaded
        KB_DEBUG("Ontology at \"{}\" already loaded.", uri);
        return true;
    }
 
    auto result = source->load([this, &backendsToLoad](const TripleContainerPtr &triples) {
        auto transaction = edb_->createTransaction(
                getBackendForQuery(),
                StorageInterface::Insert,
                StorageInterface::Including,
                backendsToLoad);
        transaction->commit(triples);
    });
    if (!result) {
        KB_WARN("Failed to load ontology \"{}\".", uri);
        return false;
    }
    finishLoad(source, source->origin(), newVersion);
 
    for (auto &imported: source->imports()) {
        auto importedSource = std::make_shared<OntologyFile>(vocabulary_, URI(imported), source->format());
        if (!loadOntologySource(importedSource)) {
            KB_WARN("Failed to load imported ontology \"{}\".", imported);
            return false;
        }
    }
 
    return true;
}

loadOntologySource() [2/2]

bool knowrob::KnowledgeBase::loadOntologySource ( const std::shared_ptr< OntologySource > &  source )

protected

observe() [1/2]

ObserverPtr KnowledgeBase::observe	(	const GraphQueryPtr &	query,
		const BindingsHandler &	callback
	)

Observe a query represented as a graph query.

Parameters

query	a graph query
callback	a function that is called for each answer to the query

Returns

an observer that can be used to cancel the query

Definition at line 407 of file KnowledgeBase.cpp.

                                                                                              {
    return observerManager_->observe(query, callback);
}

observe() [2/2]

ObserverPtr knowrob::KnowledgeBase::observe	(	const GraphQueryPtr &	query,
		const BindingsHandler &	callback
	)

Observe a query represented as a graph query.

Parameters

query	a graph query
callback	a function that is called for each answer to the query

Returns

an observer that can be used to cancel the query

prepareLoad() [1/2]

std::vector< std::shared_ptr< NamedBackend > > KnowledgeBase::prepareLoad ( std::string_view  origin, std::string_view  newVersion  ) const

protected

Definition at line 581 of file KnowledgeBase.cpp.

                                                                                 {
    std::vector<std::shared_ptr<NamedBackend>> backendsToLoad;
    for (auto &it: backendManager_->plugins()) {
        // check if the ontology is already loaded by the backend,
        // and if so whether it has the right version.
        auto definedBackend = it.second;
        auto currentVersion = getVersionOfOrigin(definedBackend, origin);
        if (currentVersion.has_value()) {
            if (currentVersion.value() != newVersion) {
                backendsToLoad.emplace_back(it.second);
                definedBackend->value()->removeAllWithOrigin(origin);
            }
        } else {
            backendsToLoad.emplace_back(it.second);
        }
    }
    return backendsToLoad;
}

prepareLoad() [2/2]

std::vector<std::shared_ptr<NamedBackend> > knowrob::KnowledgeBase::prepareLoad ( std::string_view  origin, std::string_view  newVersion  ) const

protected

reasonerManager() [1/2]

auto& knowrob::KnowledgeBase::reasonerManager ( ) const

inline

Returns

the reasoner manager of this knowledge base

Definition at line 77 of file KnowledgeBase.h.

{ return reasonerManager_; }

reasonerManager() [2/2]

auto& knowrob::KnowledgeBase::reasonerManager ( ) const

inline

Returns

the reasoner manager of this knowledge base

Definition at line 77 of file KnowledgeBase.h.

{ return reasonerManager_; }

removeAll() [1/4]

bool KnowledgeBase::removeAll

(

const std::vector< TriplePtr > &

triples

)

Remove a collection of triples from the knowledge base.

Parameters

triples

the triples to remove

Returns

true if the triples were removed successfully

Definition at line 492 of file KnowledgeBase.cpp.

                                                                 {
    return removeAll(std::make_shared<ProxyTripleContainer>(&triples));
}

removeAll() [2/4]

bool knowrob::KnowledgeBase::removeAll

(

const std::vector< TriplePtr > &

triples

)

Remove a collection of triples from the knowledge base.

Parameters

triples

the triples to remove

Returns

true if the triples were removed successfully

removeAll() [3/4]

bool KnowledgeBase::removeAll

(

const TripleContainerPtr &

triples

)

Remove a collection of triples from the knowledge base.

Parameters

triples

the triples to remove

Returns

true if the triples were removed successfully

Definition at line 472 of file KnowledgeBase.cpp.

                                                               {
    auto sourceBackend = findSourceBackend(**triples->begin());
    auto transaction = edb_->createTransaction(
            getBackendForQuery(),
            StorageInterface::Remove,
            StorageInterface::Excluding,
            {sourceBackend});
    if (transaction->commit(triples)) {
        observerManager_->remove(triples);
        return true;
    } else {
        return false;
    }
}

removeAll() [4/4]

bool knowrob::KnowledgeBase::removeAll

(

const TripleContainerPtr &

triples

)

Remove a collection of triples from the knowledge base.

Parameters

triples

the triples to remove

Returns

true if the triples were removed successfully

removeAllWithOrigin() [1/2]

bool KnowledgeBase::removeAllWithOrigin

(

std::string_view

origin

)

Remove all triples with a given origin from the knowledge base.

Parameters

origin

the origin of the triples to remove

Returns

true if the triples were removed successfully

Definition at line 496 of file KnowledgeBase.cpp.

                                                             {
    return edb_->removeAllWithOrigin(origin);
}

removeAllWithOrigin() [2/2]

bool knowrob::KnowledgeBase::removeAllWithOrigin

(

std::string_view

origin

)

Remove all triples with a given origin from the knowledge base.

Parameters

origin

the origin of the triples to remove

Returns

true if the triples were removed successfully

removeOne() [1/2]

bool KnowledgeBase::removeOne

(

const Triple &

triple

)

Remove a single triple from the knowledge base.

Parameters

triple

the triple to remove

Returns

true if the triple was removed successfully

Definition at line 453 of file KnowledgeBase.cpp.

                                                  {
    auto sourceBackend = findSourceBackend(triple);
    auto transaction = edb_->createTransaction(
            getBackendForQuery(),
            StorageInterface::Remove,
            StorageInterface::Excluding,
            {sourceBackend});
    if (transaction->commit(triple)) {
        auto tripleCopy = new TripleCopy(triple);
        std::vector<TriplePtr> triples;
        triples.emplace_back(tripleCopy);
        auto container = std::make_shared<ProxyTripleContainer>(triples);
        observerManager_->remove(container);
        return true;
    } else {
        return false;
    }
}

removeOne() [2/2]

bool knowrob::KnowledgeBase::removeOne

(

const Triple &

triple

)

Remove a single triple from the knowledge base.

Parameters

triple

the triple to remove

Returns

true if the triple was removed successfully

setDefaultGraph() [1/2]

void KnowledgeBase::setDefaultGraph

(

std::string_view

origin

)

Set the default graph for queries.

Parameters

origin

the origin of the default graph

Definition at line 680 of file KnowledgeBase.cpp.

                                                         {
    vocabulary_->importHierarchy()->setDefaultGraph(origin);
}

setDefaultGraph() [2/2]

void knowrob::KnowledgeBase::setDefaultGraph

(

std::string_view

origin

)

Set the default graph for queries.

Parameters

origin

the origin of the default graph

startReasoner() [1/2]

void KnowledgeBase::startReasoner ( )

protected

Definition at line 355 of file KnowledgeBase.cpp.

                                  {
    std::vector<std::string_view> failedToStartReasoner;
    for (auto &pair: reasonerManager_->dataDriven()) {
        KB_LOGGED_TRY_EXCEPT(pair.first.data(), "start",
                             { do_startReasoner(pair.second); },
                             { failedToStartReasoner.push_back(pair.first); });
    }
    // remove reasoner that failed to start
    for (auto &reasonerName: failedToStartReasoner) {
        reasonerManager_->removePlugin(reasonerName);
    }
}

startReasoner() [2/2]

void knowrob::KnowledgeBase::startReasoner ( )

protected

stopReasoner() [1/2]

void KnowledgeBase::stopReasoner ( )

protected

Definition at line 368 of file KnowledgeBase.cpp.

                                 {
    for (auto &pair: reasonerManager_->dataDriven()) {
        KB_LOGGED_TRY_CATCH(pair.first.data(), "stop", { pair.second->stop(); });
    }
}

stopReasoner() [2/2]

void knowrob::KnowledgeBase::stopReasoner ( )

protected

submitQuery() [1/6]

TokenBufferPtr KnowledgeBase::submitQuery

(

const ConjunctiveQueryPtr &

conjunctiveQuery

)

Evaluate a query represented as a vector of literals. The call is non-blocking and returns a stream of answers.

Parameters

conjunctiveQuery

the query

Returns

a stream of query results

Definition at line 388 of file KnowledgeBase.cpp.

                                                                                     {
    auto pipeline = std::make_shared<QueryPipeline>(shared_from_this(), conjunctiveQuery);
    // Wrap output into AnswerBuffer_WithReference object.
    // Note that the AnswerBuffer_WithReference object is used such that the caller can
    // destroy the whole pipeline by de-referencing the returned AnswerBufferPtr.
    auto out = std::make_shared<AnswerBuffer_WithReference>(pipeline);
    *pipeline >> out;
    pipeline->stopBuffering();
    return out;
}

submitQuery() [2/6]

TokenBufferPtr knowrob::KnowledgeBase::submitQuery

(

const ConjunctiveQueryPtr &

conjunctiveQuery

)

Evaluate a query represented as a vector of literals. The call is non-blocking and returns a stream of answers.

Parameters

conjunctiveQuery

the query

Returns

a stream of query results

submitQuery() [3/6]

TokenBufferPtr KnowledgeBase::submitQuery	(	const FirstOrderLiteralPtr &	query,
		const QueryContextPtr &	ctx
	)

Evaluate a query represented as a Literal. The call is non-blocking and returns a stream of answers.

Parameters

query	a literal
ctx	a query context

Returns

a stream of query results

Definition at line 384 of file KnowledgeBase.cpp.

                                                                                                         {
    return submitQuery(std::make_shared<ConjunctiveQuery>(ConjunctiveQuery({literal}, ctx)));
}

submitQuery() [4/6]

TokenBufferPtr knowrob::KnowledgeBase::submitQuery	(	const FirstOrderLiteralPtr &	query,
		const QueryContextPtr &	ctx
	)

Evaluate a query represented as a Literal. The call is non-blocking and returns a stream of answers.

Parameters

query	a literal
ctx	a query context

Returns

a stream of query results

submitQuery() [5/6]

TokenBufferPtr KnowledgeBase::submitQuery	(	const FormulaPtr &	query,
		const QueryContextPtr &	ctx
	)

Evaluate a query represented as a Formula. The call is non-blocking and returns a stream of answers.

Parameters

query	a formula
ctx	a query context

Returns

a stream of query results

Definition at line 399 of file KnowledgeBase.cpp.

                                                                                           {
    auto pipeline = std::make_shared<QueryPipeline>(shared_from_this(), phi, ctx);
    auto out = std::make_shared<AnswerBuffer_WithReference>(pipeline);
    *pipeline >> out;
    pipeline->stopBuffering();
    return out;
}

submitQuery() [6/6]

TokenBufferPtr knowrob::KnowledgeBase::submitQuery	(	const FormulaPtr &	query,
		const QueryContextPtr &	ctx
	)

Evaluate a query represented as a Formula. The call is non-blocking and returns a stream of answers.

Parameters

query	a formula
ctx	a query context

Returns

a stream of query results

synchronizeBackends() [1/2]

void KnowledgeBase::synchronizeBackends ( )

protected

Definition at line 106 of file KnowledgeBase.cpp.

                                        {
    // find all non-persistent backends, which we assume to be empty at this point
    std::vector<std::shared_ptr<NamedBackend>> nonPersistent;
    for (auto &it: backendManager_->plugins()) {
        auto backend = it.second->value();
        auto queryable = backendManager_->queryable().find(it.first);
        if (queryable == backendManager_->queryable().end() || !queryable->second->isPersistent()) {
            nonPersistent.push_back(it.second);
        }
    }
 
    // synchronize persistent backends with each other
    if (backendManager_->persistent().size() > 1) {
        // find versions of persisted origins
        using BackendOriginVersion = std::pair<std::shared_ptr<QueryableStorage>, VersionedOriginPtr>;
        std::map<std::string_view, std::vector<BackendOriginVersion>> origins;
        for (auto &it: backendManager_->persistent()) {
            auto persistentBackend = it.second;
            for (auto &origin: persistentBackend->getOrigins()) {
                origins[origin->value()].emplace_back(it.second, origin);
            }
        }
 
        // drop all persisted origins with an outdated version
        for (auto &origin_pair: origins) {
            auto &v = origin_pair.second;
            if (v.size() < 2) continue;
            // find the maximum version
            std::string_view maxVersion;
            for (auto &version: v) {
                if (!maxVersion.empty() && version.second->version() > maxVersion) {
                    maxVersion = version.second->version();
                }
            }
            // drop origin for backends with outdated version, also remove such backends from "origins" array
            v.erase(std::remove_if(v.begin(), v.end(),
                                   [&maxVersion](const BackendOriginVersion &bov) {
                                       if (bov.second->version() != maxVersion) {
                                           bov.first->removeAllWithOrigin(bov.second->value());
                                           return true;
                                       } else {
                                           return false;
                                       }
                                   }), v.end());
        }
 
        // At this point, origins contains only the backends with the latest version.
        // So data can be copied from any of them into all other persistent backends that do
        // not have the data yet.
        for (auto &origin_pair: origins) {
            // First find all persistent backends that do not appear in origin_pair.
            // These are the ones without the data.
            std::vector<std::shared_ptr<NamedBackend>> included;
            for (auto &it: backendManager_->persistent()) {
                auto &persistentBackend = it.second;
                if (std::find_if(origin_pair.second.begin(), origin_pair.second.end(),
                                 [&persistentBackend](const BackendOriginVersion &bov) {
                                     return bov.first == persistentBackend;
                                 }) == origin_pair.second.end()) {
                    included.push_back(backendManager_->getPluginWithID(it.first));
                }
            }
            if (included.empty()) continue;
 
            // Now copy the data from one of the backends in origin_pair to all backends in included.
            auto &persistedBackend = origin_pair.second.begin()->first;
            auto transaction = edb_->createTransaction(
                    persistedBackend,
                    StorageInterface::Insert,
                    StorageInterface::Including,
                    included);
            persistedBackend->batchOrigin(origin_pair.first, [&](const TripleContainerPtr &triples) {
                transaction->commit(triples);
            });
        }
    }
 
    // insert from first persistent backend into all non-persistent backends.
    // persistent backends are synchronized before, so we can just take the first one.
    if (!backendManager_->persistent().empty() && !nonPersistent.empty()) {
        KB_DEBUG("Synchronizing persistent triples into {} non-persistent backends.", nonPersistent.size());
        auto &persistedBackend = *backendManager_->persistent().begin();
        auto transaction = edb_->createTransaction(
                getBackendForQuery(),
                StorageInterface::Insert,
                StorageInterface::Including,
                nonPersistent);
        persistedBackend.second->batch([&](const TripleContainerPtr &triples) { transaction->commit(triples); });
    }
}

synchronizeBackends() [2/2]

void knowrob::KnowledgeBase::synchronizeBackends ( )

protected

synchronizeObservers() [1/2]

void KnowledgeBase::synchronizeObservers

(

)

Block until all observers have processed all queued data.

Definition at line 411 of file KnowledgeBase.cpp.

                                         {
    observerManager_->synchronize();
}

synchronizeObservers() [2/2]

void knowrob::KnowledgeBase::synchronizeObservers

(

)

Block until all observers have processed all queued data.

vocabulary() [1/2]

auto& knowrob::KnowledgeBase::vocabulary ( ) const

inline

Returns

the vocabulary of this knowledge base, i.e. all known properties and classes

Definition at line 67 of file KnowledgeBase.h.

{ return vocabulary_; }

vocabulary() [2/2]

auto& knowrob::KnowledgeBase::vocabulary ( ) const

inline

Returns

the vocabulary of this knowledge base, i.e. all known properties and classes

Definition at line 67 of file KnowledgeBase.h.

{ return vocabulary_; }

Member Data Documentation

backendManager_

std::shared_ptr< StorageManager > knowrob::KnowledgeBase::backendManager_

protected

Definition at line 186 of file KnowledgeBase.h.

edb_

std::shared_ptr< StorageInterface > knowrob::KnowledgeBase::edb_

protected

Definition at line 184 of file KnowledgeBase.h.

isInitialized_

bool knowrob::KnowledgeBase::isInitialized_

protected

Definition at line 189 of file KnowledgeBase.h.

observerManager_

std::shared_ptr< ObserverManager > knowrob::KnowledgeBase::observerManager_

protected

Definition at line 188 of file KnowledgeBase.h.

reasonerManager_

std::shared_ptr< ReasonerManager > knowrob::KnowledgeBase::reasonerManager_

protected

Definition at line 185 of file KnowledgeBase.h.

vocabulary_

std::shared_ptr< Vocabulary > knowrob::KnowledgeBase::vocabulary_

protected

Definition at line 187 of file KnowledgeBase.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/KnowledgeBase.h
• src/KnowledgeBase.cpp