KnowledgeBase.h

Go to the documentation of this file.

/*
 * This file is part of KnowRob, please consult
 * https://github.com/knowrob/knowrob for license details.
 */
 
#ifndef KNOWROB_KNOWLEDGE_BASE_H
#define KNOWROB_KNOWLEDGE_BASE_H
 
#include <memory>
#include <boost/property_tree/ptree.hpp>
#include <utility>
#include "knowrob/queries/QueryContext.h"
#include "knowrob/storage/QueryableStorage.h"
#include "knowrob/storage/StorageManager.h"
#include "knowrob/storage/StorageInterface.h"
#include "knowrob/semweb/GraphPathQuery.h"
#include "knowrob/semweb/OntologySource.h"
#include "knowrob/formulas/SimpleConjunction.h"
#include "knowrob/queries/ConjunctiveQuery.h"
#include "knowrob/storage/Observer.h"
#include "knowrob/storage/ObserverManager.h"
 
namespace knowrob {
    // forward declaration
    class ReasonerManager;
 
    class KnowledgeBase : public std::enable_shared_from_this<KnowledgeBase> {
    public:
        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();
 
        ~KnowledgeBase();
 
        void init();
 
        void loadCommon();
 
        bool loadDataSource(const DataSourcePtr &source);
 
        auto &vocabulary() const { return vocabulary_; }
 
        auto &edb() const { return edb_; }
 
        auto &reasonerManager() const { return reasonerManager_; }
 
        auto &backendManager() const { return backendManager_; }
 
        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);
 
    protected:
        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_;
 
        explicit KnowledgeBase(const boost::property_tree::ptree &config);
 
        explicit KnowledgeBase(std::string_view config);
 
        explicit KnowledgeBase();
 
        void configure(const boost::property_tree::ptree &config);
 
        static void configurePrefixes(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;
    };
 
    using KnowledgeBasePtr = std::shared_ptr<KnowledgeBase>;
}
 
#endif //KNOWROB_KNOWLEDGE_BASE_H