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 Debug.c:255:

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

In Map.Insert.c:26:

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

In Map.Insert.c:27:

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

In Map.Insert.c:28:

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

In Map.Insert.c:50:

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

In Map.Insert.c:51:

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

In Map.Insert.c:52:

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

In Map.Insert.c:98:

        // 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 Map.Insert.c:108:

            int key = 600 + (i & 0x3f); // small cycling window
            MapRemoveAll(&map, key);
            MapInsertR(&map, key, i);
        }
        result = result && (MapPairCount(&map) >= 600);

In Float.Compare.c:203:

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

In Float.Compare.c:204:

        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 Map.Foreach.c:31:

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

In Map.Foreach.c:53:

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

In Map.Foreach.c:54:

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

In Map.Foreach.c:55:

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

In Map.Foreach.c:56:

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

In Map.Foreach.c:57:

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

In Map.Remove.c:27:

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

In Map.Remove.c:46:

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

In Map.Remove.c:47:

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

In Map.Remove.c:48:

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

In Map.Remove.c:72:

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

In Map.Remove.c:73:

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

In Map.Remove.c:74:

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

In Map.Remove.c:75:

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

In Map.Remove.c:94:

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

In Map.Remove.c:95:

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

In Map.Remove.c:96:

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

In Map.Remove.c:97:

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

In Int.Compare.c:162:

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

In Int.Compare.c:163:

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

In Map.Access.c:27:

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

In Map.Access.c:52:

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

In Map.Access.c:69:

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

In Map.Access.c:86:

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

In Map.Access.c:107:

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

In Map.Access.c:108:

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

In Map.Access.c:109:

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

In Map.Access.c:110:

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

In Map.Access.c:141:

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

In Map.Access.c:142:

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

In Map.Init.c:62:

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

In Map.Init.c:63:

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

In Map.Init.c:64:

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

In Graph.Foreach.c:36:

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

In BitVec.Compare.c:1039:

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

In BitVec.Compare.c:1040:

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

In Map.Ops.c:86:

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

In Map.Ops.c:117:

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

In Map.Ops.c:118:

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

In Map.Ops.c:119:

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

In Map.Ops.c:122:

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

In Map.Ops.c:123:

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

In Map.Ops.c:162:

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

In Map.Ops.c:163:

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

In Map.Ops.c:164:

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

In Map.Ops.c:165:

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

In Insert.h:484:

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

Last updated on June 4, 2026

MapInsertL MapKeyCompare