TriplePattern.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_FRAMED_TRIPLE_PATTERN_H
#define KNOWROB_FRAMED_TRIPLE_PATTERN_H
 
#include "knowrob/formulas/Predicate.h"
#include "knowrob/semweb/Triple.h"
#include "knowrob/semweb/TripleContainer.h"
#include "knowrob/formulas/FirstOrderLiteral.h"
#include "knowrob/queries/QueryContext.h"
#include "knowrob/terms/groundable.h"
#include "knowrob/terms/Numeric.h"
#include "knowrob/terms/IRIAtom.h"
#include "knowrob/terms/Blank.h"
 
namespace knowrob {
    enum class FilterType {
        EQ = 0,
        NEQ,
        LT,
        GT,
        LEQ,
        GEQ
    };
 
    FilterType inverseFilterType(FilterType op);
 
    class TriplePattern : public FirstOrderLiteral {
    public:
        explicit TriplePattern(const Triple &triple, bool isNegated = false);
 
        explicit TriplePattern(const PredicatePtr &predicate, bool isNegated = false);
 
        TriplePattern(const TermPtr &s, const TermPtr &p, const TermPtr &o, bool isNegated = false);
 
        void setTripleFrame(const GraphSelector &frame);
 
        void getTripleFrame(GraphSelector &frame) const;
 
        auto &subjectTerm() const { return subjectTerm_; }
 
        void setSubjectTerm(const TermPtr &subjectTerm) { subjectTerm_ = subjectTerm; }
 
        auto &propertyTerm() const { return propertyTerm_; }
 
        auto &objectTerm() const { return objectTerm_; }
 
        void setObjectTerm(const TermPtr &objectTerm) { objectTerm_ = objectTerm; }
 
        auto &objectVariable() const { return objectVariable_; }
 
        void setObjectVariable(const VariablePtr &objectVariable) { objectVariable_ = objectVariable; }
 
        auto &graphTerm() const { return graphTerm_; }
 
        void setGraphTerm(const groundable<Atom> &graphTerm) { graphTerm_ = graphTerm; }
 
        void setGraphName(const std::string_view &graphName) { graphTerm_ = getGraphTerm(graphName); }
 
        auto &perspectiveTerm() const { return perspectiveTerm_; }
 
        void setPerspectiveTerm(const groundable<Atom> &perspectiveTerm) { perspectiveTerm_ = perspectiveTerm; }
 
        auto &beginTerm() const { return beginTerm_; }
 
        void setBeginTerm(const groundable<Double> &beginTerm) { beginTerm_ = beginTerm; }
 
        auto &endTerm() const { return endTerm_; }
 
        void setEndTerm(const groundable<Double> &endTerm) { endTerm_ = endTerm; }
 
        auto &confidenceTerm() const { return confidenceTerm_; }
 
        void setConfidenceTerm(const groundable<Double> &confidenceTerm) { confidenceTerm_ = confidenceTerm; }
 
        auto objectOperator() const { return objectOperator_; }
 
        void setObjectOperator(FilterType objectOperator) { objectOperator_ = objectOperator; }
 
        auto &isOccasionalTerm() const { return isOccasional_; }
 
        void setIsOccasionalTerm(const groundable<Numeric> &isOccasional) { isOccasional_ = isOccasional; }
 
        auto &isUncertainTerm() const { return isUncertain_; }
 
        void setIsUncertainTerm(const groundable<Numeric> &isUncertain) { isUncertain_ = isUncertain; }
 
        bool isOptional() const { return isOptional_; }
 
        void setIsOptional(bool isOptional) { isOptional_ = isOptional; }
 
        uint32_t numVariables() const override;
 
        std::vector<VariablePtr> getVariables(bool includeObjectVar = true) const;
 
        bool filter(const Triple &triple) const;
 
        bool instantiateInto(Triple &triple,
                             const std::shared_ptr<const Bindings> &bindings = Bindings::emptyBindings()) const;
 
        static std::shared_ptr<Predicate> getRDFPredicate(const PredicatePtr &predicate);
 
    protected:
        TermPtr subjectTerm_;
        TermPtr propertyTerm_;
        TermPtr objectTerm_;
        VariablePtr objectVariable_;
        FilterType objectOperator_;
        bool isOptional_;
 
        // below are treated as optional
        groundable<Atom> graphTerm_;
        groundable<Atom> perspectiveTerm_;
        groundable<Double> beginTerm_;
        groundable<Double> endTerm_;
        groundable<Double> confidenceTerm_;
        groundable<Numeric> isOccasional_;
        groundable<Numeric> isUncertain_;
 
        static std::shared_ptr<Atom> getGraphTerm(const std::string_view &graphName);
 
        static std::shared_ptr<Predicate> getRDFPredicate(const TermPtr &s, const TermPtr &p, const TermPtr &o);
 
        static std::shared_ptr<Predicate> getRDFPredicate(const Triple &data);
    };
 
    using TriplePatternPtr = std::shared_ptr<TriplePattern>;
 
    TriplePatternPtr applyBindings(const TriplePatternPtr &pat, const Bindings &bindings);
 
    class TriplePatternContainer : public MutableTripleContainer {
    public:
        TriplePatternContainer() = default;
 
        ~TriplePatternContainer();
 
        TriplePatternContainer(const TriplePatternContainer &other) = delete;
 
        void push_back(const TriplePatternPtr &q);
 
        // Override TripleContainer
        ConstGenerator cgenerator() const override;
 
        // Override MutableTripleContainer
        MutableGenerator generator() override;
 
    protected:
        std::vector<TriplePtr *> data_;
        std::vector<TriplePatternPtr> statements_;
    };
} // knowrob
 
#endif //KNOWROB_FRAMED_TRIPLE_PATTERN_H