#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	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	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

◆ 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.

82 { 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.

82 { return backendManager_; }

◆ configure() [1/2]

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

protected

Definition at line 250 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 283 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 490 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 266 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 294 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.

72 { 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.

72 { return edb_; }

◆ findSourceBackend() [1/2]

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

protected

Definition at line 468 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 568 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 346 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 535 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 455 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 406 of file KnowledgeBase.cpp.

                                                                {
     auto sourceBackend = findSourceBackend(**triples->begin());
     auto transaction = edb_->createTransaction(
             getBackendForQuery(),
             StorageInterface::Insert,
             StorageInterface::Excluding,
             {sourceBackend});
     if (transaction->commit(triples)) {
         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 387 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 312 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 525 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 626 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 587 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 379 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 549 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.

77 { 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.

77 { 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 460 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 440 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 464 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 421 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 648 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 327 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 340 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 360 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 356 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 371 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 383 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.

67 { 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.

67 { 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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~KnowledgeBase() [1/2]

◆ KnowledgeBase() [1/6]

◆ KnowledgeBase() [2/6]

◆ KnowledgeBase() [3/6]

◆ ~KnowledgeBase() [2/2]

◆ KnowledgeBase() [4/6]

◆ KnowledgeBase() [5/6]

◆ KnowledgeBase() [6/6]

Member Function Documentation

◆ backendManager() [1/2]

◆ backendManager() [2/2]

◆ configure() [1/2]

◆ configure() [2/2]

◆ configureBackends() [1/2]

◆ configureBackends() [2/2]

◆ configureDataSources() [1/2]

◆ configureDataSources() [2/2]

◆ configurePrefixes() [1/2]

◆ configurePrefixes() [2/2]

◆ configureReasoner() [1/2]

◆ configureReasoner() [2/2]

◆ create() [1/6]

◆ create() [2/6]

◆ create() [3/6]

◆ create() [4/6]

◆ create() [5/6]

◆ create() [6/6]

◆ edb() [1/2]

◆ edb() [2/2]

◆ findSourceBackend() [1/2]

◆ findSourceBackend() [2/2]

◆ finishLoad() [1/2]

◆ finishLoad() [2/2]

◆ getBackendForQuery() [1/2]

◆ getBackendForQuery() [2/2]

◆ getVersionOfOrigin() [1/2]

◆ getVersionOfOrigin() [2/2]

◆ init() [1/2]

◆ init() [2/2]

◆ initBackends() [1/2]

◆ initBackends() [2/2]

◆ initVocabulary() [1/2]

◆ initVocabulary() [2/2]

◆ insertAll() [1/4]

◆ insertAll() [2/4]

◆ insertAll() [3/4]

◆ insertAll() [4/4]

◆ insertOne() [1/2]

◆ insertOne() [2/2]

◆ loadCommon() [1/2]

◆ loadCommon() [2/2]

◆ loadDataSource() [1/2]

◆ loadDataSource() [2/2]

◆ loadNonOntologySource() [1/2]

◆ loadNonOntologySource() [2/2]

◆ loadOntologySource() [1/2]

◆ loadOntologySource() [2/2]

◆ observe() [1/2]

◆ observe() [2/2]

◆ prepareLoad() [1/2]

◆ prepareLoad() [2/2]

◆ reasonerManager() [1/2]

◆ reasonerManager() [2/2]

◆ removeAll() [1/4]

◆ removeAll() [2/4]

◆ removeAll() [3/4]

◆ removeAll() [4/4]

◆ removeAllWithOrigin() [1/2]

◆ removeAllWithOrigin() [2/2]

◆ removeOne() [1/2]

◆ removeOne() [2/2]

◆ setDefaultGraph() [1/2]

◆ setDefaultGraph() [2/2]