Reasoner.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_REASONER_H_
#define KNOWROB_REASONER_H_
 
#include <memory>
#include "knowrob/PropertyTree.h"
#include "knowrob/terms/Atom.h"
#include "knowrob/DataSource.h"
#include "knowrob/DataSourceHandler.h"
#include "knowrob/storage/Storage.h"
#include "knowrob/plugins/NamedPlugin.h"
#include "ReasonerError.h"
 
namespace knowrob {
    // forward declaration
    class ReasonerManager;
 
    class Reasoner : public DataSourceHandler {
    public:
        Reasoner();
 
        virtual ~Reasoner() = default;
 
        auto &reasonerName() const { return t_reasonerName_; }
 
        auto reasonerLanguage() const { return reasonerLanguage_; }
 
        auto storage() const { return storage_; }
 
        template<class T> std::shared_ptr<T> getTypedStorage() const {
            auto typed = std::dynamic_pointer_cast<T>(storage_);
            if (!typed) throw ReasonerError("Storage is not of the expected type.");
            return typed;
        }
 
        ReasonerManager &reasonerManager() const;
 
        void pushWork(const std::function<void(void)> &fn);
 
        void setStorage(const StoragePtr &storage) { storage_ = storage; }
 
        virtual bool initializeReasoner(const PropertyTree &ptree) = 0;
 
        virtual void unload() {}
 
    private:
        AtomPtr t_reasonerName_;
        ReasonerManager *reasonerManager_;
        PluginLanguage reasonerLanguage_;
        StoragePtr storage_;
 
        void setReasonerManager(ReasonerManager *reasonerManager) { reasonerManager_ = reasonerManager; }
 
        void setReasonerName(std::string_view name) { t_reasonerName_ = Atom::Tabled(name); }
 
        void setReasonerLanguage(PluginLanguage lang) { reasonerLanguage_ = lang; }
 
        friend class ReasonerManager;
    };
 
    using NamedReasoner = NamedPlugin<Reasoner>;
    using ReasonerFactory = PluginFactory<Reasoner>;
    using ReasonerPtr = std::shared_ptr<Reasoner>;
}
 
#define REASONER_PLUGIN(classType, pluginName) extern "C" { \
        std::shared_ptr<knowrob::Reasoner> knowrob_createPlugin(std::string_view pluginID) \
            { return std::make_shared<classType>(pluginID); } \
        const char* knowrob_getPluginName() { return pluginName; } }
 
#endif //KNOWROB_REASONER_H_