Feature: graph and dataset anonymizer (#415)

Author: liss-h

CMakeLists.txt

@@ -147,6 +147,7 @@ add_library(rdf4cpp
         src/rdf4cpp/writer/SerializationState.cpp
         src/rdf4cpp/IRIView.cpp
         src/rdf4cpp/IRIFactory.cpp
+        src/rdf4cpp/util/Anonymizer.cpp
         private/rdf4cpp/parser/IStreamQuadIteratorSerdImpl.cpp
         private/rdf4cpp/regex/RegexImpl.cpp
         private/rdf4cpp/regex/RegexReplacerImpl.cpp

conanfile.py

@@ -38,7 +38,7 @@ def requirements(self):
         self.requires("highway/1.2.0")
         self.requires("dice-hash/0.4.11", transitive_headers=True)
         self.requires("dice-sparse-map/0.2.9", transitive_headers=True)
-        self.requires("dice-template-library/1.13.0", transitive_headers=True)
+        self.requires("dice-template-library/1.19.0", transitive_headers=True)
 
         if self.options.with_test_deps:
             self.test_requires("doctest/2.4.11")

src/rdf4cpp/Dataset.cpp

@@ -1,4 +1,4 @@
-#include "Dataset.hpp"
+#include <rdf4cpp/Dataset.hpp>
 #include <rdf4cpp/Graph.hpp>
 #include <rdf4cpp/writer/TryWrite.hpp>
 #include <rdf4cpp/writer/SerializationState.hpp>
@@ -181,6 +181,10 @@ Dataset::iterator &Dataset::iterator::operator++() noexcept {
     return *this;
 }
 
+void Dataset::iterator::operator++(int) noexcept {
+    ++*this;
+}
+
 Dataset::iterator::reference Dataset::iterator::operator*() const noexcept {
     return cur_;
 }
@@ -189,12 +193,12 @@ Dataset::iterator::pointer Dataset::iterator::operator->() const noexcept {
     return &cur_;
 }
 
-bool Dataset::iterator::operator==(Dataset::sentinel) const noexcept {
-    return giter_ == gend_;
+bool operator==(Dataset::iterator const &self, Dataset::sentinel) noexcept {
+    return self.giter_ == self.gend_;
 }
 
-bool Dataset::iterator::operator!=(Dataset::sentinel) const noexcept {
-    return !(*this == Dataset::sentinel{});
+bool operator==(Dataset::sentinel, Dataset::iterator const &self) noexcept {
+    return self.giter_ == self.gend_;
 }
 
 void Dataset::solution_iterator::fill_solution() noexcept {
@@ -208,6 +212,17 @@ void Dataset::solution_iterator::fill_solution() noexcept {
     }
 }
 
+void Dataset::solution_iterator::advance_until_result() {
+    while (iter_ == std::default_sentinel) {
+        ++giter_;
+        if (giter_ == gend_) {
+            return;
+        }
+
+        iter_ = giter_->second.match(pat_.without_graph()).begin();
+    }
+}
+
 Dataset::solution_iterator::solution_iterator(Dataset const *parent,
                                               query::QuadPattern const &pat,
                                               typename storage_type::const_iterator beg,
@@ -217,6 +232,7 @@ Dataset::solution_iterator::solution_iterator(Dataset const *parent,
 
         if (pat_.graph().is_variable()) {
             iter_ = giter_->second.match(tpat).begin();
+            advance_until_result();
         } else if (auto const *g = parent_->find_graph(pat_.graph()); g != nullptr) {
             iter_ = g->match(tpat).begin();
         }
@@ -229,20 +245,17 @@ Dataset::solution_iterator &Dataset::solution_iterator::operator++() noexcept {
     ++iter_;
 
     if (pat_.graph().is_variable()) {
-        while (iter_ == std::default_sentinel) {
-            ++giter_;
-            if (giter_ == gend_) {
-                return *this;
-            }
-
-            iter_ = giter_->second.match(pat_.without_graph()).begin();
-        }
+        advance_until_result();
     }
 
     fill_solution();
     return *this;
 }
 
+void Dataset::solution_iterator::operator++(int) noexcept {
+    ++*this;
+}
+
 Dataset::solution_iterator::reference Dataset::solution_iterator::operator*() const noexcept {
     return cur_;
 }
@@ -251,12 +264,26 @@ Dataset::solution_iterator::pointer Dataset::solution_iterator::operator->() con
     return &cur_;
 }
 
-bool Dataset::solution_iterator::operator==(Dataset::sentinel) const noexcept {
-    return iter_ == Dataset::sentinel{};
+bool operator==(Dataset::solution_iterator const &self, Dataset::sentinel) noexcept {
+    return self.iter_ == Dataset::sentinel{};
+}
+
+bool operator==(Dataset::sentinel, Dataset::solution_iterator const &self) noexcept {
+    return self.iter_ == Dataset::sentinel{};
 }
 
-bool Dataset::solution_iterator::operator!=(Dataset::sentinel) const noexcept {
-    return !(*this == Dataset::sentinel{});
+Dataset Dataset::anonymize(util::Anonymizer &anonymizer) const {
+    Dataset anon{anonymizer.node_storage()};
+
+    for (auto const &[graph_id, graph] : graphs_) {
+        anon.graphs_.emplace(
+            anonymizer.anonymize(to_node(graph_id)).backend_handle().id(),
+            graph.anonymize(anonymizer)
+        );
+    }
+
+    return anon;
 }
 
+
 }  // namespace rdf4cpp

src/rdf4cpp/Dataset.hpp

@@ -5,6 +5,7 @@
 #include <rdf4cpp/Quad.hpp>
 #include <rdf4cpp/query/QuadPattern.hpp>
 #include <rdf4cpp/writer/BufWriter.hpp>
+#include <rdf4cpp/util/Anonymizer.hpp>
 
 #include <dice/sparse-map/sparse_map.hpp>
 
@@ -49,11 +50,12 @@ struct Dataset {
                  typename storage_type::const_iterator gend) noexcept;
 
         iterator &operator++() noexcept;
+        void operator++(int) noexcept;
         reference operator*() const noexcept;
         pointer operator->() const noexcept;
 
-        bool operator==(sentinel) const noexcept;
-        bool operator!=(sentinel) const noexcept;
+        friend bool operator==(iterator const &self, sentinel) noexcept;
+        friend bool operator==(sentinel, iterator const &self) noexcept;
     };
 
     using const_iterator = iterator;
@@ -75,6 +77,7 @@ struct Dataset {
         Graph::solution_iterator iter_;
         value_type cur_;
 
+        void advance_until_result();
         void fill_solution() noexcept;
 
     public:
@@ -84,11 +87,12 @@ struct Dataset {
                           typename storage_type::const_iterator end) noexcept;
 
         solution_iterator &operator++() noexcept;
+        void operator++(int) noexcept;
         reference operator*() const noexcept;
         pointer operator->() const noexcept;
 
-        bool operator==(sentinel) const noexcept;
-        bool operator!=(sentinel) const noexcept;
+        friend bool operator==(solution_iterator const &self, sentinel) noexcept;
+        friend bool operator==(sentinel, solution_iterator const &self) noexcept;
     };
 
     struct solution_sequence {
@@ -202,6 +206,14 @@ struct Dataset {
 
     friend std::ostream &operator<<(std::ostream &os, Dataset const &self);
 
+
+    /**
+     * Anonymize the dataset by removing all information except for the dataset structure itself.
+     *
+     * See `rdf4cpp::util::Anonymizer` for details
+     */
+    [[nodiscard]] Dataset anonymize(util::Anonymizer &anonymizer) const;
+
     // TODO: support union (+) and difference (-)
     // TODO: add empty
 };

src/rdf4cpp/Graph.cpp

@@ -1,31 +1,44 @@
-#include "Graph.hpp"
+#include <rdf4cpp/Graph.hpp>
 #include <rdf4cpp/Dataset.hpp>
 #include <rdf4cpp/writer/TryWrite.hpp>
 #include <rdf4cpp/writer/SerializationState.hpp>
 
 #include <utility>
+#include <ranges>
 
 namespace rdf4cpp {
 
 storage::identifier::NodeBackendID Graph::to_node_id(Node node) noexcept {
     return node.backend_handle().id();
 }
 
+Graph::triple Graph::to_id_triple(Statement const &stmt) noexcept {
+    return triple{
+        to_node_id(stmt.subject()),
+        to_node_id(stmt.predicate()),
+        to_node_id(stmt.object())
+    };
+}
+
 Node Graph::to_node(storage::identifier::NodeBackendID id) const noexcept {
     return Node{storage::identifier::NodeBackendHandle{id, node_storage_}};
 }
 
+Statement Graph::to_statement(triple const &t) const noexcept {
+    return Statement{to_node(t[0]), to_node(t[1]), to_node(t[2])};
+}
+
 Graph::Graph(storage::DynNodeStoragePtr node_storage) noexcept : node_storage_{node_storage} {
 }
 
 void Graph::add(Statement const &stmt_) {
     auto stmt = stmt_.to_node_storage(node_storage_);
-    triples_.insert(triple{to_node_id(stmt.subject()), to_node_id(stmt.predicate()), to_node_id(stmt.object())});
+    triples_.insert(to_id_triple(stmt));
 }
 
 bool Graph::contains(Statement const &stmt_) const noexcept {
     auto const stmt = stmt_.try_get_in_node_storage(node_storage_);
-    return triples_.contains(triple{to_node_id(stmt.subject()), to_node_id(stmt.predicate()), to_node_id(stmt.object())});
+    return triples_.contains(to_id_triple(stmt));
 }
 
 Graph::iterator Graph::begin() const noexcept {
@@ -86,27 +99,27 @@ std::ostream &operator<<(std::ostream &os, Graph const &graph) {
     return os;
 }
 
-Statement Graph::iterator::to_statement(rdf4cpp::Graph::triple const &t) const noexcept {
-    return Statement{parent_->to_node(t[0]), parent_->to_node(t[1]), parent_->to_node(t[2])};
-}
-
 Graph::iterator::iterator(Graph const *parent, typename triple_storage_type::const_iterator beg, typename triple_storage_type::const_iterator end) noexcept : parent_{parent},
                                                                                                                                                               iter_{beg},
                                                                                                                                                               end_{end} {
     if (iter_ != end_) {
-        cur_ = to_statement(*iter_);
+        cur_ = parent_->to_statement(*iter_);
     }
 }
 
 Graph::iterator &Graph::iterator::operator++() noexcept {
     ++iter_;
     if (iter_ != end_) {
-        cur_ = to_statement(*iter_);
+        cur_ = parent_->to_statement(*iter_);
     }
 
     return *this;
 }
 
+void Graph::iterator::operator++(int) noexcept {
+    ++*this;
+}
+
 Graph::reference Graph::iterator::operator*() const noexcept {
     return cur_;
 }
@@ -115,12 +128,12 @@ Graph::pointer Graph::iterator::operator->() const noexcept {
     return &cur_;
 }
 
-bool Graph::iterator::operator==(Graph::sentinel) const noexcept {
-    return iter_ == end_;
+bool operator==(Graph::iterator const &self, Graph::sentinel) noexcept {
+    return self.iter_ == self.end_;
 }
 
-bool Graph::iterator::operator!=(Graph::sentinel) const noexcept {
-    return !(*this == Graph::sentinel{});
+bool operator==(Graph::sentinel, Graph::iterator const &self) noexcept {
+    return self.iter_ == self.end_;
 }
 
 bool Graph::solution_iterator::check_solution() noexcept {
@@ -168,12 +181,22 @@ Graph::solution_iterator::pointer Graph::solution_iterator::operator->() const n
     return &cur_;
 }
 
-bool Graph::solution_iterator::operator==(Graph::sentinel) const noexcept {
-    return iter_ == Graph::sentinel{};
+bool operator==(Graph::solution_iterator const &self, Graph::sentinel) noexcept {
+    return self.iter_ == Graph::sentinel{};
+}
+
+bool operator==(Graph::sentinel, Graph::solution_iterator const &self) noexcept {
+    return self.iter_ == Graph::sentinel{};
 }
 
-bool Graph::solution_iterator::operator!=(Graph::sentinel) const noexcept {
-    return iter_ != Graph::sentinel{};
+Graph Graph::anonymize(util::Anonymizer &anonymizer) const {
+    Graph anon{anonymizer.node_storage()};
+
+    for (auto const &non_anon_triple : triples_) {
+        anon.triples_.insert(to_id_triple(anonymizer.anonymize(to_statement(non_anon_triple))));
+    }
+
+    return anon;
 }
 
 }  // namespace rdf4cpp

src/rdf4cpp/Graph.hpp

@@ -7,6 +7,7 @@
 #include <rdf4cpp/writer/BufWriter.hpp>
 #include <rdf4cpp/writer/SerializationState.hpp>
 #include <rdf4cpp/parser/RDFFileParser.hpp>
+#include <rdf4cpp/util/Anonymizer.hpp>
 
 #include <dice/sparse-map/sparse_set.hpp>
 
@@ -50,18 +51,18 @@ struct Graph {
 
         Statement cur_;
 
-        Statement to_statement(triple const &t) const noexcept;
-
     public:
         iterator() noexcept = default;
         iterator(Graph const *parent, typename triple_storage_type::const_iterator beg, typename triple_storage_type::const_iterator end) noexcept;
 
         iterator &operator++() noexcept;
+        void operator++(int) noexcept;
+
         reference operator*() const noexcept;
         pointer operator->() const noexcept;
 
-        bool operator==(sentinel) const noexcept;
-        bool operator!=(sentinel) const noexcept;
+        friend bool operator==(iterator const &self, sentinel) noexcept;
+        friend bool operator==(sentinel, iterator const &self) noexcept;
     };
 
     using const_iterator = iterator;
@@ -87,15 +88,16 @@ struct Graph {
                           query::TriplePattern const &pat) noexcept;
 
         solution_iterator &operator++() noexcept;
+        void operator++(int) noexcept;
         reference operator*() const noexcept;
         pointer operator->() const noexcept;
 
-        bool operator==(sentinel) const noexcept;
-        bool operator!=(sentinel) const noexcept;
+        friend bool operator==(solution_iterator const &self, sentinel) noexcept;
+        friend bool operator==(sentinel, solution_iterator const &self) noexcept;
     };
 
     struct solution_sequence {
-        using value_type = Statement;
+        using value_type = query::Solution;
         using size_type = size_t;
         using difference_type = ptrdiff_t;
         using reference = value_type const &;
@@ -127,7 +129,10 @@ struct Graph {
     triple_storage_type triples_;
 
     static storage::identifier::NodeBackendID to_node_id(Node node) noexcept;
-    Node to_node(storage::identifier::NodeBackendID id) const noexcept;
+    static triple to_id_triple(Statement const &stmt) noexcept;
+
+    [[nodiscard]] Node to_node(storage::identifier::NodeBackendID id) const noexcept;
+    [[nodiscard]] Statement to_statement(triple const &t) const noexcept;
 
 public:
     explicit Graph(storage::DynNodeStoragePtr node_storage = storage::default_node_storage) noexcept;
@@ -196,6 +201,13 @@ struct Graph {
      */
     friend std::ostream &operator<<(std::ostream &os, Graph const &graph);
 
+    /**
+     * Anonymize the graph by removing all information except for the graph structure itself.
+     *
+     * See `rdf4cpp::util::Anonymizer` for details
+     */
+    [[nodiscard]] Graph anonymize(util::Anonymizer &anonymizer) const;
+
     // TODO: support union (+) and difference (-); open question: which graph name should be assigned?
     // TODO: add empty
 };