groundable.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_GROUNDABLE_H
#define KNOWROB_GROUNDABLE_H
 
#include <memory>
#include <sstream>
#include "Variable.h"
#include "knowrob/Logger.h"
 
namespace knowrob {
    template<class TermType> class groundable {
    public:
        groundable() = default;
 
        explicit groundable(const std::shared_ptr<TermType> &grounded) : grounded_(grounded) {}
 
        explicit groundable(const std::shared_ptr<Variable> &variable) : variable_(variable) {}
 
        TermPtr operator*() const { return get(); }
 
        TermPtr operator()() const { return get(); }
 
        Term* operator->() const { return get().get(); }
 
        groundable& operator=(const std::shared_ptr<TermType> &grounded) { set_grounded(grounded); return *this; }
 
        groundable& operator=(const std::shared_ptr<Variable> &variable) { set_variable(variable); return *this;  }
 
        explicit operator bool() const { return has_grounding() || has_variable(); }
 
        TermPtr get() const {
            if (has_grounding()) {
                return grounded();
            } else {
                return variable();
            }
        }
 
        void set_grounded(const std::shared_ptr<TermType> &grounded) { grounded_ = grounded; variable_ = nullptr; }
 
        void set_variable(const std::shared_ptr<Variable> &variable) { grounded_ = nullptr; variable_ = variable; }
 
        bool has_grounding() const { return grounded_ != nullptr; }
 
        bool has_variable() const { return !has_grounding() && variable_ != nullptr; }
 
        auto grounded() const { return grounded_; }
 
        auto variable() const { return variable_; }
 
        static groundable<TermType> cast(const TermPtr &term) {
            if (term->isVariable()) {
                return groundable<TermType>(std::static_pointer_cast<Variable>(term));
            }
            if (auto grounded = std::dynamic_pointer_cast<TermType>(term)) {
                return groundable<TermType>(grounded);
            } else {
                KB_WARN("Cannot cast term `{}` to type `{}`.", *term, typeid(TermType).name());
                return groundable<TermType>();
            }
        }
 
    protected:
        std::shared_ptr<TermType> grounded_;
        std::shared_ptr<Variable> variable_;
    };
 
} // knowrob
 
#endif //KNOWROB_GROUNDABLE_H