Property.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_SEMWEB_PROPERTY_H
#define KNOWROB_SEMWEB_PROPERTY_H
 
#include <memory>
#include <list>
#include <functional>
#include "Resource.h"
#include "knowrob/terms/IRIAtom.h"
#include "Class.h"
 
namespace knowrob::semweb {
    enum PropertyFlag {
        DATATYPE_PROPERTY = 1 << 0,
        ANNOTATION_PROPERTY = 1 << 1,
        OBJECT_PROPERTY = 1 << 2,
        TRANSITIVE_PROPERTY = 1 << 3,
        REFLEXIVE_PROPERTY = 1 << 4,
        SYMMETRIC_PROPERTY = 1 << 5
    };
 
    // forward declaration
    class Property;
 
    // called for each parent in the property hierarchy
    using PropertyVisitor = std::function<void(Property &)>;
    // called for each parent in the property hierarchy
    using PropertyTupleVisitor = std::function<void(Property &, Property &)>;
 
    class Property : public Resource, public std::enable_shared_from_this<Property> {
    public:
        explicit Property(std::string_view iri);
 
        explicit Property(const IRIAtomPtr &iri);
 
        void addDirectParent(const std::shared_ptr<Property> &directParent, std::optional<std::string_view> graph);
 
        void removeDirectParent(const std::shared_ptr<Property> &directParent, std::optional<std::string_view> graph);
 
        const auto &directParents() const { return directParents_; }
 
        void setInverse(const std::shared_ptr<Property> &inverse);
 
        const auto &inverse() const { return inverse_; }
 
        bool hasFlag(PropertyFlag flag) const;
 
        void setFlag(PropertyFlag flag);
 
        bool isDatatypeProperty() const { return hasFlag(DATATYPE_PROPERTY); }
 
        bool isAnnotationProperty() const { return hasFlag(ANNOTATION_PROPERTY); }
 
        bool isObjectProperty() const { return hasFlag(OBJECT_PROPERTY); }
 
        bool isTransitiveProperty() const { return hasFlag(TRANSITIVE_PROPERTY); }
 
        bool isReflexiveProperty() const { return hasFlag(REFLEXIVE_PROPERTY); }
 
        bool isSymmetricProperty() const { return hasFlag(SYMMETRIC_PROPERTY); }
 
        bool isSubPropertyOf(const std::shared_ptr<Property> &parent, bool includeSelf = true);
 
        void forallParents(const PropertyVisitor &visitor, bool includeSelf = true, bool skipDuplicates = true);
 
        void forallChildren(const PropertyTupleVisitor &visitor, bool skipDuplicates = true);
 
        auto reification() const { return reification_; }
 
        static knowrob::IRIAtomPtr reifiedIRI(std::string_view iri);
 
        static knowrob::IRIAtomPtr unReifiedIRI(std::string_view iri);
 
        void detach();
 
    protected:
        struct PropertyComparator {
            bool operator()(const std::shared_ptr<Property> &lhs, const std::shared_ptr<Property> &rhs) const;
        };
 
        std::shared_ptr<Property> inverse_;
        std::map<std::shared_ptr<Property>,
                std::set<AtomPtr, AtomComparator>,
                PropertyComparator> directParents_;
        std::set<std::shared_ptr<Property>, PropertyComparator> directChildren_;
        std::shared_ptr<Class> reification_;
        int flags_;
    };
 
    using PropertyPtr = std::shared_ptr<Property>;
 
} // knowrob
 
#endif //KNOWROB_SEMWEB_PROPERTY_H