Class iterator

src/ifcparse/map_transformer.h:46–98

        : base_map_(map), transform_(transform), transform_back_(transform_back){}

    class iterator {
    public:
        using base_iterator = typename BaseMap::iterator;
        using iterator_category = std::forward_iterator_tag;
        using difference_type = typename std::iterator_traits<base_iterator>::difference_type;
        using key_type = typename BaseMap::key_type;
        using transformed_mapped_type = std::invoke_result_t<Transform, typename BaseMap::mapped_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 unchanged and the mapped value
        // is the result of applying the transform to the underlying mapped value.
        // @todo should these also all be const references so that key/value can be non-copyable (i.e unique_ptr)
        value_type operator*() const {
            auto base_val = *base_it_;
            return { base_val.first, (*transform_ptr_)(base_val.second) };
        }

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