ocean.util.container.map.Map

Template for a class implementing a mapping from a user-specified type to a user-specified type.

The interface of the class has been kept deliberately simple, purely handling the management of the mapping. The handling of the mapping values is left entirely up to the user -- all methods simply return a pointer to the mapping value which the user can do what they like with. (This is an intentional design decision, in order to reduce the complexity of the template.)

The HashMap is designed as a replacement for ocean.core.ArrayMap. It has several advantages: 1. Memory safety. As the ArrayMap's buckets are implemented as dynamic arrays, each bucket will theoretically grow continually in size over extended periods of use. Even when clear()ed, the buffers allocated for the buckets will not reduce in size. The HashMap, on the other hand, uses a pool of elements, meaning that the memory allocated for each bucket is truly variable. 2. Code simplicity via removing optional advanced features such as thread safety and value array copying. 3. Extensibility. Functionality is split into several modules, including a base class for easier reuse of components.

Usage example with various types stored in mapping:

import ocean.util.container.map.HashMap;

// Mapping from hash_t -> int
auto map = new HashMap!(int);

hash_t hash = 232323;

// Add a mapping
*(map.put(hash)) = 12;

// Check if a mapping exists (null if not found)
auto exists = hash in map;

// Remove a mapping
map.remove(hash);

// Clear the map
map.clear();

// Mapping from hash_t -> char[]
auto map2 = new HashMap!(char[]);

// Add a mapping
map2.put(hash).copy("hello");

// Mapping from hash_t -> struct
struct MyStruct
{
    int x;
    float y;
}

auto map3 = new HashMap!(MyStruct);

// Add a mapping
*(map3.put(hash)) = MyStruct(12, 23.23);