GraphBuiltin.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_GRAPH_BUILTIN_H
#define KNOWROB_GRAPH_BUILTIN_H
 
#include <utility>
 
#include "memory"
#include "knowrob/semweb/GraphTerm.h"
#include "knowrob/terms/Variable.h"
#include "knowrob/terms/Atomic.h"
#include "knowrob/terms/Function.h"
#include "knowrob/terms/Bindings.h"
 
namespace knowrob {
    enum class GraphBuiltinType {
        Bind, // Bind a value to a variable in the query pipeline.
        Min, // Calculate the minimum of two terms.
        Max, // Calculate the maximum of two terms.
        Less, // Check if the first term is less than the second term.
        LessOrEqual, // Check if the first term is less than or equal to the second term.
        Greater, // Check if the first term is greater than the second term.
        GreaterOrEqual, // Check if the first term is greater than or equal to the second term.
        Equal, // Check if the first term is equal to the second term.
        NotEqual // Check if the first term is not equal to the second term.
    };
 
    namespace graph::builtins {
        const AtomPtr bindFunctor = Atom::Tabled("bind");
 
        const AtomPtr minFunctor = Atom::Tabled("min");
 
        const AtomPtr maxFunctor = Atom::Tabled("max");
 
        const AtomPtr lessFunctor = Atom::Tabled("less");
 
        const AtomPtr lessOrEqualFunctor = Atom::Tabled("lessOrEqual");
 
        const AtomPtr greaterFunctor = Atom::Tabled("greater");
 
        const AtomPtr greaterOrEqualFunctor = Atom::Tabled("greaterOrEqual");
 
        const AtomPtr equalFunctor = Atom::Tabled("equal");
 
        const AtomPtr notEqualFunctor = Atom::Tabled("notEqual");
    }
 
    class GraphBuiltin : public GraphTerm, public Function {
    public:
        using BuiltinPtr = std::shared_ptr<GraphBuiltin>;
 
        GraphBuiltin(GraphBuiltinType builtinType,
                     const AtomPtr &functor,
                     const std::vector<TermPtr> &arguments,
                     VariablePtr bindVar = nullptr)
                : GraphTerm(GraphTermType::Builtin),
                  Function(functor, arguments),
                  builtinType_(builtinType),
                  bindVar_(std::move(bindVar)),
                  isOptional_(true) {}
 
        auto builtinType() const { return builtinType_; }
 
        auto bindVar() const { return bindVar_; }
 
        bool apply(const std::shared_ptr<Bindings> &bindings) const;
 
        static BuiltinPtr bind(const VariablePtr &var, const TermPtr &val) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Bind,
                    graph::builtins::bindFunctor,
                    std::vector<TermPtr>{val},
                    var);
        }
 
        static BuiltinPtr min(const VariablePtr &var, const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Min,
                    graph::builtins::minFunctor,
                    std::vector<TermPtr>{a, b},
                    var);
        }
 
        static BuiltinPtr max(const VariablePtr &var, const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Max,
                    graph::builtins::maxFunctor,
                    std::vector<TermPtr>{a, b},
                    var);
        }
 
        static BuiltinPtr less(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Less,
                    graph::builtins::lessFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        static BuiltinPtr lessOrEqual(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::LessOrEqual,
                    graph::builtins::lessOrEqualFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        static BuiltinPtr greater(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Greater,
                    graph::builtins::greaterFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        static BuiltinPtr greaterOrEqual(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::GreaterOrEqual,
                    graph::builtins::greaterOrEqualFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        static BuiltinPtr equal(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::Equal,
                    graph::builtins::equalFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        static BuiltinPtr notEqual(const TermPtr &a, const TermPtr &b) {
            return std::make_shared<GraphBuiltin>(
                    GraphBuiltinType::NotEqual,
                    graph::builtins::notEqualFunctor,
                    std::vector<TermPtr>{a, b});
        }
 
        bool isOptional() const { return isOptional_; }
 
        void setOptional(bool isOptional) { isOptional_ = isOptional; }
 
        // Overwritten from GraphTerm
        void write(std::ostream &os) const override { Function::write(os); }
 
    protected:
        GraphBuiltinType builtinType_;
        VariablePtr bindVar_;
        bool isOptional_;
    };
} // knowrob
 
#endif //KNOWROB_GRAPH_BUILTIN_H