Exploration of using rocksdb as file+instance storage

src/ifcparse/map_variant.h

@@ -0,0 +1,174 @@
+/********************************************************************************
+*                                                                              *
+* 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 <map>
+#include <variant>
+#include <tuple>
+#include <utility>
+#include <cstddef>
+#include <string>
+#include <iostream>
+
+// VariantMap: A map interface that delegates to one of several map types.
+// The underlying maps are referenced by pointers (not moved into the variant).
+// All map types must share the same key_type, mapped_type, and value_type.
+template <typename... Maps>
+class VariantMap {
+public:
+    // The variant holds a pointer to the map
+    using variant_type = std::variant<std::monostate, Maps*...>;
+    variant_type map_;
+
+    // Deduce common types from the first map type.
+    // @todo these are not common types, but just the 1st
+    using key_type = typename std::tuple_element<0, std::tuple<Maps...>>::type::key_type;
+    using mapped_type = typename std::tuple_element<0, std::tuple<Maps...>>::type::mapped_type;
+    using value_type = typename std::tuple_element<0, std::tuple<Maps...>>::type::value_type;
+
+    using underlying_iterator_variant = std::variant<typename Maps::iterator...>;
+
+    class iterator {
+    public:
+        using value_type = VariantMap::value_type;
+        using difference_type = std::ptrdiff_t;
+        using pointer = value_type*;
+        using reference = value_type;
+        using iterator_category = std::forward_iterator_tag;
+
+        underlying_iterator_variant it_var;
+
+        // mutable cache to support operator-> (so that it->second works)
+        mutable std::unique_ptr<value_type> cached_value_ptr_;
+
+        iterator() = default;
+
+        explicit iterator(underlying_iterator_variant v)
+            : it_var(std::move(v)) {}
+
+        iterator(const iterator& other)
+            : it_var(other.it_var), cached_value_ptr_(nullptr) {}
+
+        iterator& operator=(const iterator& other) {
+            if (this != &other) {
+                it_var = other.it_var;
+                cached_value_ptr_.reset(); // clear the cache
+            }
+            return *this;
+        }
+
+        value_type operator*() const {
+            return std::visit([](auto& it) -> value_type { return *it; }, it_var);
+        }
+
+        value_type* operator->() const {
+            // @todo we need to make a copy here (stored in unique_ptr) because the
+            // value_type appears to be pair<const K, V> instead of <K, V> or something
+            // related...
+            cached_value_ptr_ = std::make_unique<value_type>(**this);
+            return cached_value_ptr_.get();
+        }
+
+        iterator& operator++() {
+            std::visit([](auto& it) { ++it; }, it_var);
+            return *this;
+        }
+
+        iterator operator++(int) {
+            iterator tmp(*this);
+            ++(*this);
+            return tmp;
+        }
+
+        bool operator==(const iterator& other) const {
+            return it_var == other.it_var;
+        }
+
+        bool operator!=(const iterator& other) const {
+            return !(*this == other);
+        }
+    };
+
+    VariantMap() {}
+
+    template <typename MapT>
+    VariantMap(MapT* m) : map_(m) {}
+
+    iterator begin() const{
+        return std::visit([](auto m) -> iterator {
+            if constexpr (std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                return iterator{};
+            } else {
+                return iterator(m->begin());
+            }
+        }, map_);
+    }
+
+    iterator end() const {
+        return std::visit([](auto m) -> iterator {
+            if constexpr (std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                return iterator{};
+            } else {
+                return iterator(m->end());
+            }
+        }, map_);
+    }
+
+    iterator find(const key_type& key) const {
+        return std::visit([&key](auto m) -> iterator {
+            if constexpr (std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                return iterator{};
+            } else {
+                return iterator(m->find(key));
+            }
+        }, map_);
+    }
+
+    size_t erase(const key_type& key) {
+        return std::visit([&key](auto m) -> size_t {
+            if constexpr (std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                return size_t(0);
+            } else {
+                return m->erase(key);
+            }
+        }, map_);
+    }
+
+    size_t erase(const iterator& it) {
+        return std::visit([&it](auto m) -> size_t {
+            if constexpr (std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                return size_t(0);
+            } else {
+                // @todo erasing by iterator would be more efficient
+                return m->erase(it->first);
+            }
+        }, map_);
+    }
+
+    std::pair<iterator, bool> insert(const value_type& val) {
+        return std::visit([this, &val](auto m) -> std::pair<iterator, bool> {
+            // @todo is monostate still necessary here?
+            if constexpr (!std::is_same_v<std::decay_t<decltype(m)>, std::monostate>) {
+                auto result = m->insert(val);
+                return { iterator(result.first), result.second };
+            } else {
+                return { end(), false };
+            }
+        }, map_);
+    }
+};