rehash_internal()

template<typename Key, typename T, typename Hash = Hash<Key>, typename KeyEqual = EqualTo<Key>, int INLINED_COUNT = FASTLED_HASHMAP_INLINED_COUNT>

void fl::unordered_map< Key, T, Hash, KeyEqual, INLINED_COUNT >::rehash_internal ( fl::size new_cap )

inlineprivate

Definition at line 916 of file unordered_map.h.

                                                      {
        new_cap = next_power_of_two(new_cap);
#if FL_PLATFORM_HAS_LARGE_MEMORY
        // Large stacks: keep the scratch local and skip a heap round trip.
        fl::vector_inlined<Entry, INLINED_COUNT> old(_buckets.get_resource());
        fl::bitset<1024> old_occupied = _occupied;
#else
        // Small stacks: the old buckets (an inline Entry buffer) and the
        // 1024-bit occupancy copy cost about 1 KB on the stack, which
        // overflowed ESP8266's 4 KB loop stack when an RPC registry grew
        // during setup(), so they come from the map's memory resource.
        struct Scratch {
            explicit Scratch(fl::memory_resource* r) FL_NO_EXCEPT : buckets(r) {}
            fl::vector_inlined<Entry, INLINED_COUNT> buckets;
            fl::bitset<1024> occupied;
        };
        fl::memory_resource* resource = _buckets.get_resource();
        if (resource == nullptr) {
            resource = fl::default_memory_resource();
        }
        void* mem = resource->allocate(sizeof(Scratch));
        if (mem == nullptr) {
            // Out of memory: stay at the current size. The table is at most
            // 70% full, so inserts still find a slot and retry the grow.
            return;
        }
        Scratch* scratch = new (mem) Scratch(resource);
        fl::vector_inlined<Entry, INLINED_COUNT>& old = scratch->buckets;
        fl::bitset<1024>& old_occupied = scratch->occupied;
        old_occupied = _occupied;
#endif
 
        _buckets.swap(old);
        _buckets.clear();
        _buckets.assign(new_cap, Entry{});
 
        _occupied.reset();
        _occupied.resize(new_cap);
        _deleted.reset();
        _deleted.resize(new_cap);
 
        _size = _tombstones = 0;
 
        for (fl::size i = 0; i < old.size(); i++) {
            if (old_occupied.test(i))
                insert(fl::move(old[i].key), fl::move(old[i].value));
        }
#if !FL_PLATFORM_HAS_LARGE_MEMORY
        scratch->~Scratch();
        resource->deallocate(mem, sizeof(Scratch));
#endif
    }