Class iterator

src/ifcparse/map_variant.h:46–105

    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);