MapInsertR

Documentation

API Reference

MapInsertR

Description

Insert a new (key, value) pair. R-value form: key and value are treated as temporary values and are never zeroed on the caller side.

Parameters

Name	Direction	Description
`m`	in,out	Map handle.
`in_key`	in	Key expression.
`in_value`	in	Value expression.

Success

Returns true. A new (key, value) entry is stored in the map; length grows by one. Both source expressions are untouched. A rehash may have grown the underlying probe table.

Failure

Returns false on allocation failure or policy violation. The map is unchanged.

Usage example (Cross-references)

Usage examples (Cross-references)

In Insert.h:487:

    #define MapMustInsertR(m, in_key, in_value)                                                                            \
        do {                                                                                                               \
            if (!MapInsertR((m), (in_key), (in_value))) {                                                                  \
                LOG_FATAL("MapMustInsertR failed");                                                                        \
            }                                                                                                              \

In Debug.c:255:

        }
    
        if (!MapInsertR(&self->live, user_p, rec)) {
            if (self->config.force_page_backing)
                AllocatorFree(&self->page, user_p);

In Foreach.c:37:

    
        Str key_copy = StrInitFromCstr(StrBegin(name), StrLen(name), alloc);
        MapInsertR(index, key_copy, id);
        return id;
    }

In Compare.c:225:

        Float k1 = FloatFromStr("3.14", &alloc.base);
        Float k2 = FloatFromStr("2.71", &alloc.base);
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);

In Compare.c:226:

        Float k2 = FloatFromStr("2.71", &alloc.base);
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);
    
        Float probe   = FloatFromStr("314e-2", &alloc.base); // same value as k1

In Compare.c:1048:

        BitVecPush(&k2, true);
    
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);

In Compare.c:1049:

    
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);
    
        BitVec probe = BitVecInit(base);

In Compare.c:167:

        Int k3 = IntFrom(100u, &alloc.base); // duplicate of k1 by value
    
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);

In Compare.c:168:

    
        MapInsertR(&counts, k1, 1u);
        MapInsertR(&counts, k2, 2u);
    
        Int  probe   = IntFrom(100u, &alloc.base);

In Ops.c:93:

    
        MapSetOnlyR(&map, "red", "apple");
        MapInsertR(&map, "red", "cherry");
        MapSetOnlyR(&map, "yellow", "banana");
        MapSetOnlyR(&map, "green", "pear");

In Ops.c:124:

        IntIntMap        second = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&first, 1, 10);
        MapInsertR(&first, 1, 11);
        MapInsertR(&first, 2, 20);

In Ops.c:125:

    
        MapInsertR(&first, 1, 10);
        MapInsertR(&first, 1, 11);
        MapInsertR(&first, 2, 20);
        MapRemoveFirst(&first, 1);

In Ops.c:126:

        MapInsertR(&first, 1, 10);
        MapInsertR(&first, 1, 11);
        MapInsertR(&first, 2, 20);
        MapRemoveFirst(&first, 1);

In Ops.c:129:

        MapRemoveFirst(&first, 1);
    
        MapInsertR(&second, 9, 90);
        MapInsertR(&second, 10, 100);

In Ops.c:130:

    
        MapInsertR(&second, 9, 90);
        MapInsertR(&second, 10, 100);
    
        bool result = (MapTombstones(&first) == 1);

In Ops.c:173:

        bool result = MapEmpty(&map);
    
        MapInsertR(&map, 1, 10);
        result = result && !MapEmpty(&map);

In Ops.c:176:

        result = result && !MapEmpty(&map);
    
        MapInsertR(&map, 2, 20);
        result = result && !MapEmpty(&map);

In Ops.c:189:

    
        // Refill then clear -> empty.
        MapInsertR(&map, 3, 30);
        MapInsertR(&map, 4, 40);
        result = result && !MapEmpty(&map);

In Ops.c:190:

        // Refill then clear -> empty.
        MapInsertR(&map, 3, 30);
        MapInsertR(&map, 4, 40);
        result = result && !MapEmpty(&map);
        MapClear(&map);

In Ops.c:208:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Ops.c:209:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 2);

In Ops.c:210:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 2);

In Ops.c:237:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);

In Ops.c:238:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);

In Ops.c:239:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 1);

In Ops.c:240:

        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 1);

In Ops.c:273:

        int              threshold = 30;
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Ops.c:274:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapInsertR(&map, 4, 40);

In Ops.c:275:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapInsertR(&map, 4, 40);

In Ops.c:276:

        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapInsertR(&map, 4, 40);
    
        bool result = (MapRetainIf(&map, retain_values_above_threshold, &threshold) == 2);

In Ops.c:299:

        IntIntMap        map   = MapInitWithValueCompare(const_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 0, 500);
        MapInsertR(&map, 1, 510);
        MapInsertR(&map, 2, 520);

In Ops.c:300:

    
        MapInsertR(&map, 0, 500);
        MapInsertR(&map, 1, 510);
        MapInsertR(&map, 2, 520);

In Ops.c:301:

        MapInsertR(&map, 0, 500);
        MapInsertR(&map, 1, 510);
        MapInsertR(&map, 2, 520);
    
        MapClear(&map);

In Ops.c:305:

        MapClear(&map);
    
        MapInsertR(&map, 0, 999);
    
        int *v      = MapGetFirstPtr(&map, 0);

In Init.c:64:

        reserved_capacity = (size)MapCapacity(&map);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);

In Init.c:65:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapRemoveFirst(&map, 1);

In Init.c:66:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapRemoveFirst(&map, 1);
        MapClear(&map);

In Init.c:189:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapMustReserve(&map, 48);

In Init.c:190:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapMustReserve(&map, 48);

In Init.c:207:

        IntIntMap        map   = MapInitT(map, i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 6, 60);

In Init.c:208:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 6, 60);
    
        bool result = (MapKeyHash(&map) == i32_hash) && (MapKeyCompare(&map) == i32_compare) && (MapPairCount(&map) == 2);

In Init.c:236:

                      (MapValueCopyDeinit(&map) == (GenericCopyDeinit)zstr_deinit);
    
        MapInsertR(&map, "alpha", "first");
        result = result && (MapPairCount(&map) == 1);
        result = result && MapGetFirstPtr(&map, "alpha") && (ZstrCompare(*MapGetFirstPtr(&map, "alpha"), "first") == 0);

In Insert.c:344:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);

In Insert.c:345:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapSetOnlyR(&map, 2, 200);

In Insert.c:346:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapSetOnlyR(&map, 2, 200);
        MapSetOnlyR(&map, 3, 30);

In Insert.c:368:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 1, 12);

In Insert.c:369:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 1, 12);
        MapSetFirstR(&map, 1, 100);

In Insert.c:370:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 1, 12);
        MapSetFirstR(&map, 1, 100);

In Insert.c:399:

        result      = result && (MapPairCount(&map) == 0) && !MapContainsKey(&map, 7);
    
        MapInsertR(&map, 1, 10);
    
        // Miss on a populated map (key absent): returns false, map unchanged.

In Insert.c:423:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);

In Insert.c:424:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
        bool result = (MapValueCountForKey(&map, 5) == 3);

In Insert.c:425:

        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
        bool result = (MapValueCountForKey(&map, 5) == 3);

In Insert.c:472:

        int              value = 84;
    
        MapInsertR(&map, key, value);
    
        bool result = (key == 42) && (value == 84);

In Insert.c:516:

        int              value = 110;
    
        MapInsertR(&map, 11, 10);
    
        // Update-existing path: first value replaced, value source zeroed.

In Insert.c:549:

        // Phase 1: fill past the first few growth thresholds.
        for (int i = 0; i < 600; ++i) {
            MapInsertR(&map, i, i * 10);
        }
        result = result && (MapPairCount(&map) == 600);

In Insert.c:559:

            int key = 600 + (i & 0x3f); // small cycling window
            MapRemoveAll(&map, key);
            MapInsertR(&map, key, i);
        }
        // Deterministic count: 600 base keys (0..599) survive untouched, plus

In Insert.c:633:

    
        // MapSet aliases MapSetOnlyL: replace + zero both sources.
        MapInsertR(&map, 1, 99); // give key 1 a second value
        result = result && (MapValueCountForKey(&map, 1) == 2);
        int k2 = 1;

In Insert.c:716:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Insert.c:717:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Insert.c:718:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
    
        MapPolicy bad = make_validate_only_reject_policy();

In Insert.c:738:

    
        result = result && (MapPairCount(&map) == 0);
        MapInsertR(&map, 5, 50);
        result = result && MapGetFirstPtr(&map, 5) && (*MapGetFirstPtr(&map, 5) == 50);

In Insert.c:754:

    
        bool result = MapCompact(&map);
        MapInsertR(&map, 7, 70);
        result = result && MapGetFirstPtr(&map, 7) && (*MapGetFirstPtr(&map, 7) == 70);

In Insert.c:768:

    
        bool result = MapCompact(&map);
        MapInsertR(&map, 8, 80);
        MapInsertR(&map, 9, 90);
        result = result && MapGetFirstPtr(&map, 8) && (*MapGetFirstPtr(&map, 8) == 80);

In Insert.c:769:

        bool result = MapCompact(&map);
        MapInsertR(&map, 8, 80);
        MapInsertR(&map, 9, 90);
        result = result && MapGetFirstPtr(&map, 8) && (*MapGetFirstPtr(&map, 8) == 80);
        result = result && MapGetFirstPtr(&map, 9) && (*MapGetFirstPtr(&map, 9) == 90);

In Insert.c:784:

    
        bool result = MapCompact(&map);
        MapInsertR(&map, 11, 110);
        result = result && MapGetFirstPtr(&map, 11) && (*MapGetFirstPtr(&map, 11) == 110);

In Insert.c:800:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Insert.c:801:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Insert.c:802:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
    
        MapPolicy tight  = make_tight_policy();

In Insert.c:828:

    
        for (int k = 0; k < 10; k++)
            MapInsertR(&map, k, k * 10);
    
        MapPolicy sab = make_sabotage_policy();

In Insert.c:847:

    
        for (int k = 0; k < 6; k++)
            MapInsertR(&map, k, k * 10);
    
        fa.fail_now = true;              // force the new-table allocation to fail

In Insert.c:874:

        const int keys[] = {0, 8, 16, 24, 32, 40};
        for (int i = 0; i < 6; i++)
            MapInsertR(&map, keys[i], keys[i] + 1);
    
        bool result = (MapPairCount(&map) == 6);

In Insert.c:932:

    
        for (int k = 0; k < 6; k++)
            result = result && MapInsertR(&map, k, k * 100 + 1);
    
        result = result && (MapPairCount(&map) == 6);

In Insert.c:956:

    
        for (int k = 0; k < 8; k++)
            result = result && MapInsertR(&map, k, k * 100 + 3);
    
        result = result && MapInsertR(&map, 8, 8 * 100 + 3);

In Insert.c:958:

            result = result && MapInsertR(&map, k, k * 100 + 3);
    
        result = result && MapInsertR(&map, 8, 8 * 100 + 3);
    
        result = result && (MapPairCount(&map) == 9);

In Insert.c:977:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 7, 70);
        MapRemoveFirst(&map, 7);
        bool result = (MapTombstones(&map) == 1);

In Insert.c:981:

        bool result = (MapTombstones(&map) == 1);
    
        MapInsertR(&map, 7, 71); // reuses the tombstone slot for key 7
        result = result && (MapTombstones(&map) == 0);
        result = result && MapGetFirstPtr(&map, 7) && (*MapGetFirstPtr(&map, 7) == 71);

In Insert.c:998:

    
        g_value_copy_should_fail = false;
        bool result              = MapInsertR(&map, 5, 50);
        MapRemoveFirst(&map, 5);
        result = result && (MapTombstones(&map) == 1);

In Insert.c:1003:

    
        g_value_copy_should_fail = true;
        bool reinserted          = MapInsertR(&map, 5, 51);
        g_value_copy_should_fail = false;

In Insert.c:1037:

        const int keys[] = {0, 16, 32, 48, 64};
        for (int i = 0; i < 5; i++)
            MapInsertR(&map, keys[i], keys[i] + 1);
    
        MapRehashWithPolicy(&map, 8, policy);

In Insert.c:1062:

        IntIntMap        map    = MapInitWithPolicy(i32_hash, i32_compare, policy, &alloc);
    
        MapInsertR(&map, 1, 10);
        bool result = (MapCapacity(&map) == 42);

In Insert.c:1092:

    
        for (int k = 0; k < 7; k++)
            MapInsertR(&map, k, k);
    
        bool result = (MapCapacity(&map) == 16);

In Insert.c:1112:

    
        for (int k = 0; k < 5; k++)
            MapInsertR(&map, k, k);
        MapRemoveAll(&map, 1);
        MapRemoveAll(&map, 3);

In Insert.c:1117:

        bool result = (MapTombstones(&map) == 2);
    
        MapInsertR(&map, 200, 200); // exactly on the 3/4 boundary -> must rehash
    
        result = result && (MapTombstones(&map) == 0);

In Insert.c:1137:

    
        for (int k = 0; k < 6; k++)
            MapInsertR(&map, k, k);
    
        bool result = (MapCapacity(&map) == 8);

In Insert.c:1156:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 7, 70);
        bool result = (MapTombstones(&map) == 0);

In Insert.c:1185:

    
        for (int k = 0; k < 8; k++)
            MapInsertR(&map, k, k * 100 + 3);
        bool result = (MapCapacity(&map) == 8) && (MapPairCount(&map) == 8);

In Insert.c:1188:

        bool result = (MapCapacity(&map) == 8) && (MapPairCount(&map) == 8);
    
        MapInsertR(&map, 8, 803); // probe budget exhausted -> recover with n = cap+1 = 9
    
        result = result && (MapCapacity(&map) == 16);

In Deadend.c:71:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Deadend.c:72:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Deadend.c:73:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
    
        GenericMap *g           = GENERIC_MAP(&map);

In Deadend.c:483:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
    
        GenericMap *g   = GENERIC_MAP(&map);

In Deadend.c:503:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);          // capacity becomes 8
    
        GenericMap *g  = GENERIC_MAP(&map);

In Deadend.c:633:

        };
        IntIntMap map    = MapInitWithPolicy(i32_hash, i32_compare, policy, &alloc);
        bool      result = MapInsertR(&map, 1, 10);
        result           = result && MapGetFirstPtr(&map, 1) && (*MapGetFirstPtr(&map, 1) == 10);

In Deadend.c:698:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        bool result = MapInsertR(&map, 7, 70); // first ops clear the validated bit
        result      = result && MapGetFirstPtr(&map, 7) && (*MapGetFirstPtr(&map, 7) == 70);

In Remove.c:40:

    
        MapSetOnlyR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapSetOnlyR(&map, 2, 20);

In Remove.c:67:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);

In Remove.c:68:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 2, 20);
    
        u64 length_before     = MapPairCount(&map);

In Remove.c:89:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);

In Remove.c:90:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);

In Remove.c:91:

        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
    
        bool result = MapRemovePair(&map, 5, 51);

In Remove.c:112:

        IntIntMap        map   = MapInitWithValueCompare(i32_hash, i32_compare, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);

In Remove.c:113:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
    
        u64 length_before     = MapPairCount(&map);

In Remove.c:161:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        bool result = (MapTombstones(&map) == 0);

In Remove.c:168:

        result = result && !MapContainsKey(&map, 5);
    
        MapInsertR(&map, 5, 51);
        result     = result && (MapTombstones(&map) == 0);
        result     = result && (MapPairCount(&map) == 1);

In Remove.c:216:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);

In Remove.c:217:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 31);

In Remove.c:218:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 31);

In Remove.c:219:

        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 31);
    
        bool result = (MapRemoveIf(&map, remove_even_values, NULL) == 2);

In Remove.c:238:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);

In Remove.c:239:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
        MapInsertR(&map, 9, 90);

In Remove.c:240:

        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
        MapInsertR(&map, 9, 90);

In Remove.c:241:

        MapInsertR(&map, 5, 51);
        MapInsertR(&map, 5, 52);
        MapInsertR(&map, 9, 90);
    
        bool result = (MapRemoveAll(&map, 5) == 3);

In Remove.c:261:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 9, 90);

In Remove.c:262:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 9, 90);
    
        u64 length_before     = MapPairCount(&map);

In Remove.c:342:

        );
    
        MapInsertR(&map, "alpha", "one");
        MapInsertR(&map, "alpha", "two");
        MapInsertR(&map, "beta", "three");

In Remove.c:343:

    
        MapInsertR(&map, "alpha", "one");
        MapInsertR(&map, "alpha", "two");
        MapInsertR(&map, "beta", "three");
        MapInsertR(&map, "gamma", "four");

In Remove.c:344:

        MapInsertR(&map, "alpha", "one");
        MapInsertR(&map, "alpha", "two");
        MapInsertR(&map, "beta", "three");
        MapInsertR(&map, "gamma", "four");

In Remove.c:345:

        MapInsertR(&map, "alpha", "two");
        MapInsertR(&map, "beta", "three");
        MapInsertR(&map, "gamma", "four");
    
        // Live allocations are non-zero here (clones + table storage).

In Remove.c:392:

    
        // The chain still accepts new keys, and every live key stays retrievable.
        result  = result && MapInsertR(&map, 5, 55) && MapInsertR(&map, 6, 66);
        result  = result && (MapPairCount(&map) == 4);
        int *v5 = MapGetFirstPtr(&map, 5);

In Foreach.c:31:

            MapSetOnlyR(&map, i, i * 10);
        }
        MapInsertR(&map, 2, 25);
    
        MapForeachPairPtr(&map, key_ptr, value_ptr) {

In Foreach.c:53:

        int              key_two_sum    = 0;
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);

In Foreach.c:54:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);

In Foreach.c:55:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);

In Foreach.c:56:

        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);

In Foreach.c:57:

        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);
    
        MapForeachKey(&map, key) {

In Foreach.c:96:

        for (int i = 1; i <= 4; i++)
            MapSetOnlyR(&map, i, i * 10);
        MapInsertR(&map, 2, 25);
    
        MapForeachPair(&map, key, value) {

In Foreach.c:129:

        IntIntMap        map   = MapInit(i32_hash, i32_compare, &alloc);
    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);

In Foreach.c:130:

    
        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Foreach.c:131:

        MapInsertR(&map, 1, 10);
        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);

In Foreach.c:132:

        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
    
        int before_sum = 0;

In Access.c:97:

    
        for (int k = 0; k < 60; k++)
            MapInsertR(&map, k, k * 10 + 1);
    
        MapInsertR(&map, 0, 7777);

In Access.c:99:

            MapInsertR(&map, k, k * 10 + 1);
    
        MapInsertR(&map, 0, 7777);
    
        bool result = (MapValueCountForKey(&map, 0) == 2);

In Access.c:128:

        MapReserve(&map, 6);
        for (int k = 10; k <= 15; k++)
            MapInsertR(&map, k, k);
    
        MapValueCursor cursor = MapFindFirstForKey(&map, 15);

In Access.c:149:

    
        MapSetOnlyR(&map, 7, 70);
        MapInsertR(&map, 7, 71);
        MapSetOnlyR(&map, 9, 90);

In Access.c:174:

    
        MapSetOnlyR(&map, 11, 110);
        MapInsertR(&map, 11, 111);
    
        int *value  = MapGetFirstPtr(&map, 11);

In Access.c:194:

    
        MapSetOnlyR(&map, 11, 110);
        MapInsertR(&map, 11, 111);
    
        int *value  = MapGetFirstPtr(&map, 11);

In Access.c:251:

    
        MapSetOnlyR(&map, 11, 110);
        MapInsertR(&map, 11, 111);
    
        int  found  = MapGetOrDefault(&map, 11, 999);

In Access.c:272:

        int              seen      = 0;
    
        MapInsertR(&map, 4, 40);
        MapInsertR(&map, 4, 41);
        MapInsertR(&map, 4, 42);

In Access.c:273:

    
        MapInsertR(&map, 4, 40);
        MapInsertR(&map, 4, 41);
        MapInsertR(&map, 4, 42);
        MapInsertR(&map, 9, 90);

In Access.c:274:

        MapInsertR(&map, 4, 40);
        MapInsertR(&map, 4, 41);
        MapInsertR(&map, 4, 42);
        MapInsertR(&map, 9, 90);

In Access.c:275:

        MapInsertR(&map, 4, 41);
        MapInsertR(&map, 4, 42);
        MapInsertR(&map, 9, 90);
    
        cursor = MapFindFirstForKey(&map, 4);

In Access.c:317:

        MapValueCursor   cursor = MapValueCursorInvalid();
    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);

In Access.c:318:

    
        MapInsertR(&map, 5, 50);
        MapInsertR(&map, 5, 51);
    
        cursor = MapFindFirstForKey(&map, 5);

In Access.c:350:

        // Distinct keys, all in one bucket.
        for (int k = 0; k < 8; k++)
            MapInsertR(&map, k, k * 100 + 7);
    
        bool result = (MapPairCount(&map) == 8) && (MapUniqueKeyCount(&map) == 8);

In Access.c:363:

        // Multivalued key inside the colliding chain: count is per-key, not
        // per-bucket.
        MapInsertR(&map, 3, 999);
        result = result && (MapValueCountForKey(&map, 3) == 2);
        result = result && (MapValueCountForKey(&map, 4) == 1);

In Access.c:397:

        // Insert: distinct keys, all colliding into one bucket.
        for (int k = 0; k < KEY_COUNT; k++)
            MapInsertR(&map, k, k * 100 + 7);
    
        bool result = (MapPairCount(&map) == KEY_COUNT) && (MapUniqueKeyCount(&map) == KEY_COUNT);

Last updated on July 1, 2026

MapInsertL MapKeyCompare