Class const_iterator

src/fl/stl/unordered_map.h:242–297

    };

    struct const_iterator {
        // Standard iterator typedefs
        // using difference_type = std::ptrdiff_t;
        using value_type = pair<const Key, T>;
        using pointer = const value_type *;
        using reference = const value_type &;
        using iterator_category = fl::forward_iterator_tag;

        const_iterator() FL_NOEXCEPT : _map(nullptr), _idx(0) {}
        const_iterator(const unordered_map *m, fl::size idx) : _map(m), _idx(idx) {
            advance_to_occupied();
        }
        const_iterator(const iterator &it) : _map(it._map), _idx(it._idx) {}

        reference operator*() const {
            auto &e = _map->_buckets[_idx];
            // Entry and pair<const Key, T> have the same memory layout
            // Safe to reinterpret since we only add const to Key
            return *fl::bit_cast<const value_type*>(&e);
        }

        pointer operator->() const {
            return &(operator*());
        }

        const_iterator &operator++() {
            ++_idx;
            advance_to_occupied();
            return *this;
        }

        const_iterator operator++(int) {
            const_iterator tmp = *this;
            ++(*this);
            return tmp;
        }

        bool operator==(const const_iterator &o) const {
            return _map == o._map && _idx == o._idx;
        }
        bool operator!=(const const_iterator &o) const { return !(*this == o); }

        void advance_to_occupied() {
            if (!_map)
                return;
            fl::size cap = _map->_buckets.size();
            while (_idx < cap && !_map->is_occupied(_idx))
                ++_idx;
        }

        friend class unordered_map;

      private:
        const unordered_map *_map;
        fl::size _idx;
    };

    iterator begin() { return iterator(this, 0); }