Re: Mimicking C++'s indexing behavior in D associative arrays

[FG via Digitalmars-d-learn]

// Assume bar is some associative array of type Foo[string]
Foo* value = key in bar;
if (!value) {
     bar[key] = Foo.init;
     value = &bar[key];
}
This seems sub-optimal, given that in involves three hashes (two lookups
and one insertion). Is there a more efficient or cleaner way to do so?

So basically:

Foo v = bar.get(key, Foo.init)
bar[key] = v;

Get is like an ordinary index but it will return the given value if it does not 
exist in the AA.

Of course you probably want to create a new UFCS function to wrap your check + 
default initialize if it doesn't exist.

T grab(T, U)(T[U] aa, U key) if (is(T == struct)) {
     if (key !in aa)
         aa[key] = new T;
     return aa[key];
}

You are searching for the key twice and the original example used pointers.


There is a function called _aaGetX in the runtime that has exactly the required 
behaviour:

    // Get pointer to value in associative array indexed by key.
    // Add entry for key if it is not already there.
    void* _aaGetX(AA* aa, const TypeInfo keyti, in size_t valuesize, in void* 
pkey)

however, using it in normal code could be considered a hack, because it belongs 
to the internal implementation of associative arrays. Anyway, while waiting for 
a better solution to present itself, we might as well have a look at this very 
dirty one. ;)


    extern(C) void* _aaGetX(void* aa, const TypeInfo keyti, in size_t 
valuesize, in void* pkey);
        
    V* aaGet(K, V)(V[K] arr, K key) {
        return cast(V*)_aaGetX(cast(void*)&arr, typeid(K), V.sizeof, 
cast(void*)&key);
    }

    unittest {
        int[int] arr = [1: 10, 2: 20, 3: 30];
        
        int *val = arr.aaGet(3); // an existing value
        assert(*val == 30);
        
        val = arr.aaGet(4); // aa[4] will be created
        assert(*val == int.init);
        assert(arr[4] == int.init);
    }