DataDrivenReasoner.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_DATA_DRIVEN_REASONER_H
#define KNOWROB_DATA_DRIVEN_REASONER_H
 
#include "Reasoner.h"
#include "ReasonerEvent.h"
 
namespace knowrob {
    class DataDrivenReasoner : public Reasoner {
    public:
        enum Feature {
            // The reasoner does not have any special features.
            NothingSpecial = 1 << 0,
            // The reasoner updates itself, thus `update` does not need to be called externally.
            UpdatesItself = 1 << 1,
            // The reasoner invalidates itself, thus `update` does not need to be called periodically
            // in case no invalidation happens.
            InvalidatesItself = 1 << 2
        };
 
        DataDrivenReasoner();
 
        void enableFeature(Feature feature);
 
        bool hasFeature(Feature feature) const;
 
        void setUpdateInterval(double intervalInSeconds);
 
        auto updateInterval() const { return updateInterval_; }
 
        void emit(const std::shared_ptr<reasoner::Event> &event);
 
        void observe(const std::shared_ptr<GraphQuery> &query, const BindingsHandler &handler);
 
        void observe(const std::string &queryString, const BindingsHandler &handler);
 
        virtual void update() = 0;
 
        virtual void start();
 
        virtual void stop();
 
    protected:
        bool isUpdateQueued_ = false;
        bool isRunning_ = false;
        bool isInvalidated_ = true;
        std::chrono::duration<double> updateInterval_ = std::chrono::seconds(1);
        uint32_t features_ = NothingSpecial;
        std::set<TriplePtr> inferredTriples_;
        std::shared_ptr<ThreadPool::Runner> updateRunner_;
        std::chrono::time_point<std::chrono::high_resolution_clock> lastUpdate_;
 
        void processAssertion(const std::vector<TriplePtr> &triples);
 
        void processRetraction(const std::vector<TriplePtr> &triples);
 
        void processReplacement(const std::vector<TriplePtr> &triples);
 
        void processInvalidation();
 
        void setReasonerOrigin(const std::vector<TriplePtr> &triples);
 
        void doUpdate();
 
        void queueUpdate();
    };
 
    using DataDrivenReasonerPtr = std::shared_ptr<DataDrivenReasoner>;
}
 
#endif //KNOWROB_DATA_DRIVEN_REASONER_H