Non-streaming rocksdb serializer nearing completion

src/ifcparse/set_to_map_transformer.h

@@ -0,0 +1,113 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+// map_transformer: wraps a set-like construct so that its iterator returns
+// a value_type where of the underlying set element as the key, with the value
+// that same key transformed via a function.
+template <typename BaseSet, typename Transform>
+class set_to_map_transformer {
+public:
+    using key_type = typename BaseSet::value_type;
+    using transformed_mapped_type = std::invoke_result_t<Transform, key_type>;
+    using value_type = std::pair<key_type, transformed_mapped_type>;
+    using mapped_type = transformed_mapped_type;
+
+private:
+    BaseSet* base_map_;
+    Transform transform_;
+
+public:
+    set_to_map_transformer(BaseSet* map, Transform transform)
+        : base_map_(map), transform_(transform) {}
+
+    class iterator {
+    public:
+        using base_iterator = typename BaseSet::iterator;
+        using iterator_category = std::forward_iterator_tag;
+        using difference_type = typename std::iterator_traits<base_iterator>::difference_type;
+        using key_type = typename BaseSet::key_type;
+        using transformed_mapped_type = std::invoke_result_t<Transform, key_type>;
+        using value_type = std::pair<key_type, transformed_mapped_type>;
+
+    private:
+        base_iterator base_it_;
+        Transform* transform_ptr_;
+
+        mutable value_type cached_value_;
+
+    public:
+        iterator() : base_it_(), transform_ptr_(nullptr) {}
+        iterator(base_iterator base_it, Transform* transform_ptr)
+            : base_it_(base_it), transform_ptr_(transform_ptr) {}
+
+        // On dereference, return a pair where the key is the set value and the mapped value
+        // is the result of applying the transform to the underlying  value.
+        value_type operator*() const {
+            auto base_val = *base_it_;
+            return { base_val, (*transform_ptr_)(base_val) };
+        }
+
+        // operator-> uses a mutable cache to return a pointer to the current value.
+        value_type* operator->() const {
+            cached_value_ = **this;
+            return &cached_value_;
+        }
+
+        iterator& operator++() {
+            ++base_it_;
+            return *this;
+        }
+
+        iterator operator++(int) {
+            iterator tmp(*this);
+            ++(*this);
+            return tmp;
+        }
+
+        bool operator==(const iterator& other) const {
+            return base_it_ == other.base_it_;
+        }
+
+        bool operator!=(const iterator& other) const {
+            return !(*this == other);
+        }
+    };
+
+    iterator begin() {
+        return iterator(base_map_->begin(), &transform_);
+    }
+
+    iterator end() {
+        return iterator(base_map_->end(), &transform_);
+    }
+
+    iterator find(const key_type& k) {
+        return iterator(base_map_->find(k), &transform_);
+    }
+
+    size_t erase(const key_type& k) {
+        // @todo
+        return 0;
+    }
+};