Spatial conclusion

CMakeLists.txt

@@ -12,7 +12,7 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(SEMPR_VERSION_MAJOR 0)
-set(SEMPR_VERSION_MINOR 1)
+set(SEMPR_VERSION_MINOR 3)
 set(SEMPR_VERSION_PATCH 0)
 
 ##

cmake/UseODB.cmake

@@ -37,7 +37,7 @@ function(odb_compile outvar)
 
 	#list(APPEND ODB_ARGS -x "${CMAKE_CXX_COMPILER}")
 
-	list(APPEND ODB_ARGS --show-sloc)
+	#list(APPEND ODB_ARGS --show-sloc)
 
 	if(PARAM_MULTI_DATABASE)
 		list(APPEND ODB_ARGS --multi-database "${PARAM_MULTI_DATABASE}")

include/sempr/core/RDF.hpp

@@ -3,67 +3,73 @@
 
 #include <string>
 #include <vector>
+#include <functional>
 
 namespace sempr {
     const std::string& baseURI();
 
+    const std::string buildURI(const std::string& id, const std::string& baseURI);
+    const std::string extractID(const std::string& uri, const std::string& baseURI);
+
     namespace core {
 
-namespace xsd {
-    const std::string& baseURI();
-}
+        namespace xsd {
+            const std::string& baseURI();
+        }
 
-namespace rdf {
-    const std::string& baseURI();
-    const std::string& type();
-}
+        namespace rdf {
+            const std::string& baseURI();
+            const std::string& type();
+        }
 
-namespace rdfs {
-#   define RDFS(name) const std::string& (name)();
-    RDFS(baseURI)
-    RDFS(Resource)
-    RDFS(Class)
-    RDFS(subClassOf)
-    RDFS(subPropertyOf)
-    RDFS(domain)
-    RDFS(range)
-#   undef RDFS
-}
+        namespace rdfs {
+            const std::string& baseURI();
+        #   define RDFS(name) const std::string& (name)();
+            RDFS(baseURI)
+            RDFS(Resource)
+            RDFS(Class)
+            RDFS(subClassOf)
+            RDFS(subPropertyOf)
+            RDFS(domain)
+            RDFS(range)
+        #   undef RDFS
+        }
 
-namespace owl {
-#   define OWL(name) const std::string& (name)();
-    OWL(baseURI)
-    OWL(Class)
-    OWL(FunctionalProperty)
-    OWL(Nothing)
-    OWL(ObjectProperty)
-    OWL(Restriction)
-    OWL(Thing)
-    OWL(allValuesFrom)
-    OWL(cardinality)
-    OWL(differentFrom)
-    OWL(disjointWith)
-    OWL(distinctMembers)
-    OWL(equivalentClass)
-    OWL(equivalentProperty)
-    OWL(hasValue)
-    OWL(intersectionOf)
-    OWL(inverseOf)
-    OWL(maxCardinality)
-    OWL(minCardinality)
-    OWL(onClass)
-    OWL(onDataRange)
-    OWL(onDatatype)
-    OWL(oneOf)
-    OWL(onProperty)
-    OWL(sameAs)
-    OWL(someValuesFrom)
-    OWL(unionOf)
-#   undef OWL
-}
+        namespace owl {
+            const std::string& baseURI();
+        #   define OWL(name) const std::string& (name)();
+            OWL(baseURI)
+            OWL(Class)
+            OWL(FunctionalProperty)
+            OWL(Nothing)
+            OWL(ObjectProperty)
+            OWL(Restriction)
+            OWL(Thing)
+            OWL(allValuesFrom)
+            OWL(cardinality)
+            OWL(differentFrom)
+            OWL(disjointWith)
+            OWL(distinctMembers)
+            OWL(equivalentClass)
+            OWL(equivalentProperty)
+            OWL(hasValue)
+            OWL(intersectionOf)
+            OWL(inverseOf)
+            OWL(maxCardinality)
+            OWL(minCardinality)
+            OWL(onClass)
+            OWL(onDataRange)
+            OWL(onDatatype)
+            OWL(oneOf)
+            OWL(onProperty)
+            OWL(sameAs)
+            OWL(someValuesFrom)
+            OWL(unionOf)
+        #   undef OWL
+        }
 
 
-} /* core */
+    } /* core */
 
 } /* sempr */
 

include/sempr/entity/GeometricObject.hpp

@@ -0,0 +1,47 @@
+#ifndef SEMPR_ENTITY_GEOMETRICOBJECT_H_
+#define SEMPR_ENTITY_GEOMETRICOBJECT_H_
+
+#include <sempr/entity/Entity.hpp>
+#include <sempr/entity/spatial/Geometry.hpp>
+#include <sempr/entity/SemanticEntity.hpp>
+#include <sempr/core/RDF.hpp>
+#include <odb/core.hxx>
+
+#include <string>
+
+namespace sempr { namespace entity {
+
+
+#pragma db object
+class GeometricObject : public SemanticEntity {
+    SEMPR_ENTITY
+public:
+    using Ptr = std::shared_ptr<GeometricObject>;
+
+    GeometricObject();
+    GeometricObject(bool temporary);
+    GeometricObject(const core::IDGenBase*, bool temporary = false);
+
+    const Geometry::Ptr geometry() const { return geometry_; }
+    void geometry(const Geometry::Ptr geometry);
+
+    const std::string type() const { return type_; }
+    void type(const std::string& type);
+
+    void registerProperty(const std::string& predicate, const std::string& object);
+
+    // Gives all related object by a known predicate. (could be empty for all related objects)
+    std::set<std::string> related(const std::string& predicate = "");
+
+private:
+    friend class odb::access;
+
+    Geometry::Ptr geometry_;
+
+    std::string type_;
+};
+
+}}
+
+
+#endif /* end of include guard: SEMPR_ENTITY_GEOMETRICOBJECT_H_ */

include/sempr/entity/RDFEntity.hpp

@@ -72,7 +72,7 @@ class RDFEntity : public Entity {
     virtual TripleIteratorWrapper end() const;
 
 protected:
-    RDFEntity(const core::IDGenBase*);
+    RDFEntity(const core::IDGenBase*, bool temporary = false);
 private:
     friend class odb::access;
     RDFEntity();

include/sempr/entity/RDFPropertyMap.hpp

@@ -1,7 +1,7 @@
 #ifndef SEMPR_ENTITY_RDFPROPERTYMAP_HPP_
 #define SEMPR_ENTITY_RDFPROPERTYMAP_HPP_
 
-#include <sempr/entity/RDFVector.hpp>
+#include <sempr/entity/RDFEntity.hpp>
 #include <sempr/entity/RDFValue.hpp>
 #include <Soprano/Soprano> // for conversion to rdf-literals.
 

include/sempr/entity/RDFValue.hpp

@@ -2,7 +2,10 @@
 #define SEMPR_ENTITY_RDFVALUE_HPP_
 
 #include <memory>
+#include <string>
+#include <tuple>
 #include <type_traits>
+
 #include <Soprano/Soprano>
 #include <odb/core.hxx>
 #include <sempr/entity/Entity.hpp>

include/sempr/entity/RDFVector.hpp

@@ -2,12 +2,8 @@
 #define SEMPR_ENTITY_RDFVECTOR_H_
 
 #include <odb/core.hxx>
-#include <sempr/core/RDF.hpp>
-#include <sempr/entity/Entity.hpp>
-#include <sempr/entity/Triple.hpp>
-#include <sempr/entity/RDFEntity.hpp>
 
-#include <sempr/core/EntityEvent.hpp>
+#include <sempr/entity/RDFEntity.hpp>
 
 #include <vector>
 
@@ -26,20 +22,19 @@ class RDFVectorIterator : public TripleIterator {
     bool operator == (const TripleIterator& other) const override;
 };
 
-
-
 #pragma db object
 class RDFVector : public RDFEntity {
     SEMPR_ENTITY
 public:
     using Ptr = std::shared_ptr<RDFVector>;
     RDFVector();
-    RDFVector(const core::IDGenBase*);
+    RDFVector(bool temporary);
+    RDFVector(const core::IDGenBase*, bool temporary = false);
     virtual ~RDFVector(){}
 
     void getTriples(std::vector<Triple>& triples) const;
     const Triple& getTripleAt(const size_t index);
-    bool addTriple(const Triple& triple);
+    bool addTriple(const Triple& triple, bool replace = false);     // if replace than an equal triple will be removed before, otherwise there a multiple entries possible
     bool removeTriple(const Triple& triple);
     void removeTripleAt(const size_t index);
     void clear();
@@ -48,11 +43,15 @@ class RDFVector : public RDFEntity {
     TripleIteratorWrapper begin() const override;
     TripleIteratorWrapper end() const override;
 
+    bool validity(const Triple& triple) const;
+
 protected:
     friend class odb::access;
     std::vector<Triple> triples_;
 };
 
+
+
 }}
 
 #endif /* end of include guard: SEMPR_ENTITY_RDFVECTOR_H_ */

include/sempr/entity/SemanticEntity.hpp

@@ -149,6 +149,8 @@ class RegisteredPropertyBase {
     std::string predicate() const;
     virtual std::string object() const = 0;
     virtual bool isValid() const = 0;
+
+    bool operator==(const RegisteredPropertyBase& other) const;
 };
 
 /**
@@ -234,7 +236,7 @@ class RegisteredProperty : public RegisteredPropertyBase {
 
     public:
         MyEntity() {
-            registerPropetry("<http://some.ontology/somePredicate>", myInt_);
+            registerProperty("<http://some.ontology/somePredicate>", myInt_);
             registerProperty("<http://some.ontology/someSubject>", "<http://some.ontology/somePredicate>", myFloat_);
         }
     };
@@ -250,9 +252,13 @@ class SemanticEntity : public RDFEntity {
     #pragma db transient
     std::vector<RegisteredPropertyBase*> properties_;
 
+    std::vector<RegisteredPropertyBase*>::iterator findProperty(const RegisteredPropertyBase& prop);
+
 protected:
-    SemanticEntity(const core::IDGenBase*);
     SemanticEntity();
+    SemanticEntity(bool temporary);
+    SemanticEntity(const core::IDGenBase*, bool temporary = false);
+
 
     /**
         Registers the property at this semantic entity. This will provide the RDF-Triple:
@@ -268,6 +274,13 @@ class SemanticEntity : public RDFEntity {
         properties_.push_back(rprop);
     }
 
+    template <class T>
+    void removeProperty(const std::string& predicate, T& property)
+    {
+        auto prop = findProperty(RegisteredProperty<T>(predicate, property));
+        properties_.erase(prop);
+    }
+
     template <class T>
     void registerPropertyPlain(const std::string& predicate, T& property)
     {
@@ -276,20 +289,33 @@ class SemanticEntity : public RDFEntity {
         properties_.push_back(rprop);
     }
 
+    template <class T>
+    void removePropertyPlain(const std::string& predicate, T& property)
+    {
+        auto prop = findProperty(RegisteredProperty<T, sempr::rdf::traits::plain_string>(predicate, property));
+        properties_.erase(prop);
+    }
+
     /**
         Registers the property at this semantic entity. This allows setting both subject and
         predicate of the resulting triple.
 
         Assumes the given property is a member of this SemanticEntity.
     */
     template <class T>
-    void registerProperty(const std::string& subject, const std::string& predicate,
-                          T& property)
+    void registerProperty(const std::string& subject, const std::string& predicate, T& property)
     {
         RegisteredPropertyBase* rprop = new RegisteredProperty<T>(subject, predicate, property);
         properties_.push_back(rprop);
     }
 
+    template <class T>
+    void removeProperty(const std::string& subject, const std::string& predicate, T& property)
+    {
+        auto prop = findProperty(RegisteredProperty<T>(subject, predicate, property));
+        properties_.erase(prop);
+    }
+
     template <class T>
     void registerPropertyPlain(const std::string& subject, const std::string& predicate, T& property)
     {
@@ -298,6 +324,13 @@ class SemanticEntity : public RDFEntity {
         properties_.push_back(rprop);
     }
 
+    template <class T>
+    void removePropertyPlain(const std::string& subject, const std::string& predicate, T& property)
+    {
+        auto prop = findProperty(RegisteredProperty<T, sempr::rdf::traits::plain_string>(subject, predicate, property));
+        properties_.erase(prop);
+    }
+
 public:
     ~SemanticEntity();