PrologTerm.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_PROLOG_TERM_H
#define KNOWROB_PROLOG_TERM_H
 
#include <SWI-Prolog.h>
#include "knowrob/terms/Term.h"
#include "knowrob/formulas/Formula.h"
#include "knowrob/formulas/CompoundFormula.h"
#include "knowrob/semweb/Triple.h"
#include "knowrob/semweb/TriplePattern.h"
#include "knowrob/semweb/GraphQuery.h"
#include "knowrob/semweb/GraphBuiltin.h"
#include "knowrob/terms/Function.h"
#include "knowrob/terms/ListTerm.h"
#include <iostream>
 
//#define KNOWROB_USE_PROLOG_RDF11
#define KNOWROB_USE_PROLOG_RDF_DB
 
namespace knowrob {
    class PrologTerm : public Printable {
    public:
        static const atom_t &ATOM_fail();
 
        static const atom_t &ATOM_false();
 
        static const atom_t &ATOM_true();
 
        static const atom_t &ATOM_comma();
 
        static const atom_t &ATOM_semicolon();
 
        static const functor_t &FUNCTOR_comma();
 
        static const functor_t &FUNCTOR_semicolon();
 
        static const predicate_t &PREDICATE_comma();
 
        static const predicate_t &PREDICATE_semicolon();
 
        PrologTerm();
 
        explicit PrologTerm(const GraphQueryPtr &query);
 
        explicit PrologTerm(const std::shared_ptr<GraphTerm> &kbTerm);
 
        explicit PrologTerm(const TermPtr &kbTerm);
 
        explicit PrologTerm(const FormulaPtr &kbFormula);
 
        explicit PrologTerm(const TriplePattern &literal, const char *triple_functor);
 
        PrologTerm(const Triple &triple, std::string_view functor);
 
        PrologTerm(const std::vector<PrologTerm> &args, std::string_view functor);
 
        template<typename ... Args>
        explicit PrologTerm(std::string_view functor, Args &&... args)
                : PrologTerm(readArgs(std::forward<Args>(args)...), functor) {}
 
        PrologTerm(const PrologTerm &other) = default;
 
        term_t operator()() const { return plTerm_; }
 
        PrologTerm operator&(const PrologTerm &other) const;
 
        PrologTerm operator|(const PrologTerm &other) const;
 
        PrologTerm operator~() const;
 
        void setModule(std::string_view module) { module_ = module; }
 
        auto module() const { return module_; }
 
        bool putTriple(std::string_view functor, const Triple &triple);
 
        bool putTerm(const TermPtr &kbTerm);
 
        bool putTerm(const std::shared_ptr<GraphTerm> &kbTerm);
 
        bool putFormula(const FormulaPtr &phi);
 
        bool isGround() const { return vars_.empty(); }
 
        auto &vars() const { return vars_; }
 
        qid_t openQuery(int flags) const;
 
        static bool nextSolution(qid_t qid);
 
        TermPtr toKnowRobTerm() const;
 
        FormulaPtr toKnowRobFormula() const;
 
        static TermPtr toKnowRobTerm(const term_t &t);
 
        static FormulaPtr toKnowRobFormula(const TermPtr &t);
 
        static std::string getVarName(term_t plTerm);
 
        static PrologTerm nil();
 
        static bool display(std::ostream &os, term_t t, const std::string &indent = "");
 
        // Printable interface
        void write(std::ostream &os) const override;
 
    protected:
        std::map<Variable, term_t, std::less<>> vars_;
        std::optional<std::string_view> module_;
        term_t plTerm_;
        bool isRDFTerm_ = false;
        bool isRDFFilter_ = false;
 
        bool putFormula(const FormulaPtr &phi, term_t plTerm);
 
        bool putFunction(Function *fn, term_t pl_term);
 
        bool putList(ListTerm *list, term_t pl_term);
 
        bool putTerm(const TermPtr &kbTerm, term_t plTerm);
 
        bool putCompound(CompoundFormula *phi, term_t pl_term, const functor_t &pl_functor);
 
        bool putCompoundTerm(term_t plTerm, std::string_view functor, const std::vector<PrologTerm> &args);
 
        bool putTerm(const std::shared_ptr<GraphTerm> &term, term_t plTerm);
 
        bool putTriplePattern(const TriplePattern &pattern, const char *functor, term_t plTerm);
 
        static bool putNativeAtomic(const std::shared_ptr<Atomic> &atomic, term_t pl_term);
 
        bool putRDFAtomic(const std::shared_ptr<Atomic> &atomic, term_t pl_term) const;
 
        bool putBuiltin(const std::shared_ptr<GraphBuiltin> &builtin, term_t plTerm);
 
        void unifyVars(const PrologTerm &other);
 
        template<typename ... Args>
        std::vector<PrologTerm> readArgs(Args &&... args) {
            // use a fold expression to convert the arguments to a vector
            // @see https://en.cppreference.com/w/cpp/language/fold
            std::vector<PrologTerm> argTerms;
            ([&args, &argTerms] { argTerms.push_back(PrologTerm(args)); }(), ...);
            return argTerms;
        }
 
        friend class PrologList;
    };
 
    class PrologList : public PrologTerm {
    public:
        explicit PrologList(const std::vector<PrologTerm> &elements);
    };
 
} // knowrob
 
#endif //KNOWROB_PROLOG_TERM_H