Method insert

Fleece/Support/ConcurrentMap.cc:177–218

    __hot
    ConcurrentMap::result ConcurrentMap::insert(slice key, value_t value, hash_t hash) {
        assert_precondition(key);
        const char *allocedKey = nullptr;
        int i = indexOfHash(hash);
        while (true) {
        retry:
            Entry current = _entries[i];
            switch (current.keyOffset) {
                case kEmptyKeyOffset:
                case kDeletedKeyOffset: {
                    // Found an empty or deleted entry to use. First allocate the string:
                    if (!allocedKey) {
                        if (_count >= _capacity)
                            return {};          // Hash table overflow
                        allocedKey = allocKey(key);
                        if (!allocedKey)
                            return {};          // Key-strings overflow
                    }
                    Entry newEntry = {keyToOffset(allocedKey), value};
                    // Try to store my new entry, if another thread didn't beat me to it:
                    if (_usuallyFalse(!_entries[i].compareAndSwap(current, newEntry))) {
                        // I was beaten to it; retry (at the same index,
                        // in case CAS was a false negative)
                        goto retry;
                    }
                    // Success!
                    ++_count;
                    assert(_count <= _capacity);
                    return {slice(allocedKey, key.size), value};
                }
                default:
                    if (auto keyPtr = offsetToKey(current.keyOffset); equalKeys(keyPtr, key)) {
                        // Key already exists in table. Deallocate any string I allocated:
                        freeKey(allocedKey);
                        return {slice(keyPtr, key.size), current.value};
                    }
                    break;
            }
            i = wrap(i + 1);
        }
    }


    bool ConcurrentMap::remove(slice key, hash_t hash) {