Dqn/dqn_containers.h

#pragma once
#include "dqn.h"

/*
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//    $$$$$$\   $$$$$$\  $$\   $$\ $$$$$$$$\  $$$$$$\  $$$$$$\ $$\   $$\ $$$$$$$$\ $$$$$$$\   $$$$$$\
//   $$  __$$\ $$  __$$\ $$$\  $$ |\__$$  __|$$  __$$\ \_$$  _|$$$\  $$ |$$  _____|$$  __$$\ $$  __$$\
//   $$ /  \__|$$ /  $$ |$$$$\ $$ |   $$ |   $$ /  $$ |  $$ |  $$$$\ $$ |$$ |      $$ |  $$ |$$ /  \__|
//   $$ |      $$ |  $$ |$$ $$\$$ |   $$ |   $$$$$$$$ |  $$ |  $$ $$\$$ |$$$$$\    $$$$$$$  |\$$$$$$\
//   $$ |      $$ |  $$ |$$ \$$$$ |   $$ |   $$  __$$ |  $$ |  $$ \$$$$ |$$  __|   $$  __$$<  \____$$\
//   $$ |  $$\ $$ |  $$ |$$ |\$$$ |   $$ |   $$ |  $$ |  $$ |  $$ |\$$$ |$$ |      $$ |  $$ |$$\   $$ |
//   \$$$$$$  | $$$$$$  |$$ | \$$ |   $$ |   $$ |  $$ |$$$$$$\ $$ | \$$ |$$$$$$$$\ $$ |  $$ |\$$$$$$  |
//    \______/  \______/ \__|  \__|   \__|   \__|  \__|\______|\__|  \__|\________|\__|  \__| \______/
//
//   dqn_containers.h -- Data structures for storing data (e.g. arrays and hash tables)
//
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// [$CARR] DN_CArray --            -- Basic operations on C arrays for VArray/SArray/FArray to reuse
// [$VARR] DN_VArray -- DN_VARRAY -- Array backed by virtual memory arena
// [$SARR] DN_SArray -- DN_SARRAY -- Array that are allocated but cannot resize
// [$FARR] DN_FArray -- DN_FARRAY -- Fixed-size arrays
// [$SLIC] DN_Slice  --            -- Pointe and length container of data
// [$DMAP] DN_DSMap  -- DN_DSMAP  -- Hashtable, 70% max load, PoT size, linear probe, chain repair
// [$LIST] DN_List   -- DN_LIST   -- Chunked linked lists, append only
//
////////////////////////////////////////////////////////////////////////////////////////////////////
*/

// NOTE: [$CARR] DN_CArray ////////////////////////////////////////////////////////////////////////
enum DN_ArrayErase
{
    DN_ArrayErase_Unstable,
    DN_ArrayErase_Stable,
};

struct DN_ArrayEraseResult
{
    // The next index your for-index should be set to such that you can continue
    // to iterate the remainder of the array, e.g:
    //
    // for (DN_USize index = 0; index < array.size; index++) {
    //     if (erase)
    //          index = DN_FArray_EraseRange(&array, index, -3, DN_ArrayErase_Unstable);
    // }
    DN_USize it_index;
    DN_USize items_erased; // The number of items erased
};

template <typename T> struct DN_ArrayFindResult
{
    T        *data;  // Pointer to the value if a match is found, null pointer otherwise
    DN_USize index; // Index to the value if a match is found, 0 otherwise
};

#if !defined(DN_NO_VARRAY)
// NOTE: [$VARR] DN_VArray ////////////////////////////////////////////////////////////////////////
// TODO(doyle): Add an API for shrinking the array by decomitting pages back to 
// the OS.
template <typename T> struct DN_VArray
{
    T       *data;   // Pointer to the start of the array items in the block of memory
    DN_USize size;   // Number of items currently in the array
    DN_USize max;    // Maximum number of items this array can store
    DN_USize commit; // Bytes committed

    T       *begin()       { return data; }
    T       *end  ()       { return data + size; }
    T const *begin() const { return data; }
    T const *end  () const { return data + size; }
};
#endif // !defined(DN_NO_VARRAY)

#if !defined(DN_NO_SARRAY)
// NOTE: [$SARR] DN_SArray ////////////////////////////////////////////////////////////////////////
template <typename T> struct DN_SArray
{
    T       *data; // Pointer to the start of the array items in the block of memory
    DN_USize size; // Number of items currently in the array
    DN_USize max;  // Maximum number of items this array can store

    T       *begin()       { return data; }
    T       *end  ()       { return data + size; }
    T const *begin() const { return data; }
    T const *end  () const { return data + size; }
};
#endif // !defined(DN_NO_SARRAY)

#if !defined(DN_NO_FARRAY)
// NOTE: [$FARR] DN_FArray ////////////////////////////////////////////////////////////////////////
template <typename T, DN_USize N> struct DN_FArray
{
    T        data[N]; // Pointer to the start of the array items in the block of memory
    DN_USize size;    // Number of items currently in the array

    T       *begin()       { return data; }
    T       *end  ()       { return data + size; }
    T const *begin() const { return data; }
    T const *end  () const { return data + size; }
};

template <typename T> using DN_FArray8  = DN_FArray<T, 8>;
template <typename T> using DN_FArray16 = DN_FArray<T, 16>;
template <typename T> using DN_FArray32 = DN_FArray<T, 32>;
template <typename T> using DN_FArray64 = DN_FArray<T, 64>;
#endif // !defined(DN_NO_FARRAY)

#if !defined(DN_NO_DSMAP)
// NOTE: [$DMAP] DN_DSMap /////////////////////////////////////////////////////////////////////////
enum DN_DSMapKeyType
{
                                       // Key    | Key Hash         | Map Index
    DN_DSMapKeyType_Invalid,
    DN_DSMapKeyType_U64,               // U64    | Hash(U64)        | Hash(U64)        % map_size
    DN_DSMapKeyType_U64NoHash,         // U64    | U64              | U64              % map_size
    DN_DSMapKeyType_Buffer,            // Buffer | Hash(buffer)     | Hash(buffer)     % map_size
    DN_DSMapKeyType_BufferAsU64NoHash, // Buffer | U64(buffer[0:4]) | U64(buffer[0:4]) % map_size
};

struct DN_DSMapKey
{
    DN_DSMapKeyType  type;
    DN_U32           hash; // Hash to lookup in the map. If it equals, we check that the original key payload matches
    void const      *buffer_data;
    DN_U32           buffer_size;
    DN_U64           u64;
    bool             no_copy_buffer;
};

template <typename T>
struct DN_DSMapSlot
{
    DN_DSMapKey key;   // Hash table lookup key
    T           value; // Hash table value
};

typedef DN_U32 DN_DSMapFlags;
enum DN_DSMapFlags_
{
    DN_DSMapFlags_Nil                   = 0,
    DN_DSMapFlags_DontFreeArenaOnResize = 1 << 0,
};

using DN_DSMapHashFunction = DN_U32(DN_DSMapKey key, DN_U32 seed);
template <typename T> struct DN_DSMap
{
    DN_U32               *hash_to_slot;  // Mapping from hash to a index in the slots array
    DN_DSMapSlot<T>      *slots;         // Values of the array stored contiguously, non-sorted order
    DN_U32                size;          // Total capacity of the map and is a power of two
    DN_U32                occupied;      // Number of slots used in the hash table
    DN_Arena             *arena;         // Backing arena for the hash table
    DN_Pool               pool;          // Allocator for keys that are variable-sized buffers
    DN_U32                initial_size;  // Initial map size, map cannot shrink on erase below this size
    DN_DSMapHashFunction *hash_function; // Custom hashing function to use if field is set
    DN_U32                hash_seed;     // Seed for the hashing function, when 0, DN_DS_MAP_DEFAULT_HASH_SEED is used
    DN_DSMapFlags         flags;
};

template <typename T> struct DN_DSMapResult
{
    bool             found;
    DN_DSMapSlot<T> *slot;
    T               *value;
};
#endif // !defined(DN_NO_DSMAP)

#if !defined(DN_NO_LIST)
// NOTE: [$LIST] DN_List //////////////////////////////////////////////////////////////////////////
template <typename T> struct DN_ListChunk
{
    T               *data;
    DN_USize         size;
    DN_USize         count;
    DN_ListChunk<T> *next;
    DN_ListChunk<T> *prev;
};

template <typename T> struct DN_ListIterator
{
    DN_B32           init;             // True if DN_List_Iterate has been called at-least once on this iterator
    DN_ListChunk<T> *chunk;            // The chunk that the iterator is reading from
    DN_USize         chunk_data_index; // The index in the chunk the iterator is referencing
    DN_USize         index;            // The index of the item in the list as if it was flat array
    T               *data;             // Pointer to the data the iterator is referencing. Nullptr if invalid.
};

template <typename T> struct DN_List
{
    DN_USize         count;      // Cumulative count of all items made across all list chunks
    DN_USize         chunk_size; // When new ListChunk's are required, the minimum 'data' entries to allocate for that node.
    DN_ListChunk<T> *head;
    DN_ListChunk<T> *tail;
};
#endif // !defined(DN_NO_LIST)

template <typename T>                           DN_ArrayEraseResult   DN_CArray_EraseRange              (T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
template <typename T>                           T *                   DN_CArray_MakeArray               (T *data, DN_USize *size, DN_USize max, DN_USize count, DN_ZeroMem zero_mem);
template <typename T>                           T *                   DN_CArray_InsertArray             (T *data, DN_USize *size, DN_USize max, DN_USize index, T const *items, DN_USize count);
template <typename T>                           T                     DN_CArray_PopFront                (T *data, DN_USize *size, DN_USize count);
template <typename T>                           T                     DN_CArray_PopBack                 (T *data, DN_USize *size, DN_USize count);
template <typename T>                           DN_ArrayFindResult<T> DN_CArray_Find                    (T *data, DN_USize size, T const &value);

#if !defined(DN_NO_VARRAY)
template <typename T>                           DN_VArray<T>          DN_VArray_InitByteSize            (DN_USize byte_size);
template <typename T>                           DN_VArray<T>          DN_VArray_Init                    (DN_USize max);
template <typename T>                           DN_VArray<T>          DN_VArray_InitSlice               (DN_Slice<T> slice, DN_USize max);
template <typename T, DN_USize N>               DN_VArray<T>          DN_VArray_InitCArray              (T const (&items)[N], DN_USize max);
template <typename T>                           void                  DN_VArray_Deinit                  (DN_VArray<T> *array);
template <typename T>                           bool                  DN_VArray_IsValid                 (DN_VArray<T> const *array);
template <typename T>                           DN_Slice<T>           DN_VArray_Slice                   (DN_VArray<T> const *array);
template <typename T>                           bool                  DN_VArray_Reserve                 (DN_VArray<T> *array, DN_USize count);
template <typename T>                           T *                   DN_VArray_AddArray                (DN_VArray<T> *array, T const *items, DN_USize count);
template <typename T, DN_USize N>               T *                   DN_VArray_AddCArray               (DN_VArray<T> *array, T const (&items)[N]);
template <typename T>                           T *                   DN_VArray_Add                     (DN_VArray<T> *array, T const &item);
#define                                                               DN_VArray_AddArrayAssert(...)     DN_HARD_ASSERT(DN_VArray_AddArray(__VA_ARGS__))
#define                                                               DN_VArray_AddCArrayAssert(...)    DN_HARD_ASSERT(DN_VArray_AddCArray(__VA_ARGS__))
#define                                                               DN_VArray_AddAssert(...)          DN_HARD_ASSERT(DN_VArray_Add(__VA_ARGS__))
template <typename T>                           T *                   DN_VArray_MakeArray               (DN_VArray<T> *array, DN_USize count, DN_ZeroMem zero_mem);
template <typename T>                           T *                   DN_VArray_Make                    (DN_VArray<T> *array, DN_ZeroMem zero_mem);
#define                                                               DN_VArray_MakeArrayAssert(...)    DN_HARD_ASSERT(DN_VArray_MakeArray(__VA_ARGS__))
#define                                                               DN_VArray_MakeAssert(...)         DN_HARD_ASSERT(DN_VArray_Make(__VA_ARGS__))
template <typename T>                           T *                   DN_VArray_InsertArray             (DN_VArray<T> *array, DN_USize index, T const *items, DN_USize count);
template <typename T, DN_USize N>               T *                   DN_VArray_InsertCArray            (DN_VArray<T> *array, DN_USize index, T const (&items)[N]);
template <typename T>                           T *                   DN_VArray_Insert                  (DN_VArray<T> *array, DN_USize index, T const &item);
#define                                                               DN_VArray_InsertArrayAssert(...)  DN_HARD_ASSERT(DN_VArray_InsertArray(__VA_ARGS__))
#define                                                               DN_VArray_InsertCArrayAssert(...) DN_HARD_ASSERT(DN_VArray_InsertCArray(__VA_ARGS__))
#define                                                               DN_VArray_InsertAssert(...)       DN_HARD_ASSERT(DN_VArray_Insert(__VA_ARGS__))
template <typename T>                           T                     DN_VArray_PopFront                (DN_VArray<T> *array, DN_USize count);
template <typename T>                           T                     DN_VArray_PopBack                 (DN_VArray<T> *array, DN_USize count);
template <typename T>                           DN_ArrayEraseResult   DN_VArray_EraseRange              (DN_VArray<T> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
template <typename T>                           void                  DN_VArray_Clear                   (DN_VArray<T> *array, DN_ZeroMem zero_mem);
#endif // !defined(DN_NO_VARRAY)
// NOTE: [$SARR] DN_SArray ////////////////////////////////////////////////////////////////////////
#if !defined(DN_NO_SARRAY)
template <typename T>                           DN_SArray<T>          DN_SArray_Init                    (DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem);
template <typename T>                           DN_SArray<T>          DN_SArray_InitSlice               (DN_Arena *arena, DN_Slice<T> slice, DN_USize size, DN_ZeroMem zero_mem);
template <typename T, size_t N>                 DN_SArray<T>          DN_SArray_InitCArray              (DN_Arena *arena, T const (&array)[N], DN_USize size, DN_ZeroMem);
template <typename T>                           DN_SArray<T>          DN_SArray_InitBuffer              (T* buffer, DN_USize size);
template <typename T>                           bool                  DN_SArray_IsValid                 (DN_SArray<T> const *array);
template <typename T>                           DN_Slice<T>           DN_SArray_Slice                   (DN_SArray<T> const *array);
template <typename T>                           T *                   DN_SArray_AddArray                (DN_SArray<T> *array, T const *items, DN_USize count);
template <typename T, DN_USize N>               T *                   DN_SArray_AddCArray               (DN_SArray<T> *array, T const (&items)[N]);
template <typename T>                           T *                   DN_SArray_Add                     (DN_SArray<T> *array, T const &item);
#define                                                               DN_SArray_AddArrayAssert(...)     DN_HARD_ASSERT(DN_SArray_AddArray(__VA_ARGS__))
#define                                                               DN_SArray_AddCArrayAssert(...)    DN_HARD_ASSERT(DN_SArray_AddCArray(__VA_ARGS__))
#define                                                               DN_SArray_AddAssert(...)          DN_HARD_ASSERT(DN_SArray_Add(__VA_ARGS__))
template <typename T>                           T *                   DN_SArray_MakeArray               (DN_SArray<T> *array, DN_USize count, DN_ZeroMem zero_mem);
template <typename T>                           T *                   DN_SArray_Make                    (DN_SArray<T> *array, DN_ZeroMem zero_mem);
#define                                                               DN_SArray_MakeArrayAssert(...)    DN_HARD_ASSERT(DN_SArray_MakeArray(__VA_ARGS__))
#define                                                               DN_SArray_MakeAssert(...)         DN_HARD_ASSERT(DN_SArray_Make(__VA_ARGS__))
template <typename T>                           T *                   DN_SArray_InsertArray             (DN_SArray<T> *array, DN_USize index, T const *items, DN_USize count);
template <typename T, DN_USize N>               T *                   DN_SArray_InsertCArray            (DN_SArray<T> *array, DN_USize index, T const (&items)[N]);
template <typename T>                           T *                   DN_SArray_Insert                  (DN_SArray<T> *array, DN_USize index, T const &item);
#define                                                               DN_SArray_InsertArrayAssert(...)  DN_HARD_ASSERT(DN_SArray_InsertArray(__VA_ARGS__))
#define                                                               DN_SArray_InsertCArrayAssert(...) DN_HARD_ASSERT(DN_SArray_InsertCArray(__VA_ARGS__))
#define                                                               DN_SArray_InsertAssert(...)       DN_HARD_ASSERT(DN_SArray_Insert(__VA_ARGS__))
template <typename T>                           T                     DN_SArray_PopFront                (DN_SArray<T> *array, DN_USize count);
template <typename T>                           T                     DN_SArray_PopBack                 (DN_SArray<T> *array, DN_USize count);
template <typename T>                           DN_ArrayEraseResult   DN_SArray_EraseRange              (DN_SArray<T> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
template <typename T>                           void                  DN_SArray_Clear                   (DN_SArray<T> *array);
#endif // !defined(DN_NO_SARRAY)
#if !defined(DN_NO_FARRAY)
#define                                                              DN_FArray_ToSArray(array)          DN_SArray_InitBuffer((array)->data, DN_ARRAY_UCOUNT((array)->data))
template <typename T, DN_USize N>             DN_FArray<T, N>        DN_FArray_Init                     (T const *array, DN_USize count);
#define                                                              DN_FArray_HasData(array)           ((array).data && (array).size)
template <typename T, DN_USize N>             DN_FArray<T, N>        DN_FArray_InitSlice                (DN_Slice<T> slice);
template <typename T, DN_USize N, DN_USize K> DN_FArray<T, N>        DN_FArray_InitCArray               (T const (&items)[K]);
template <typename T, DN_USize N>             bool                   DN_FArray_IsValid                  (DN_FArray<T, N> const *array);
template <typename T, DN_USize N>             DN_USize               DN_FArray_Max                      (DN_FArray<T, N> const *) { return N; }
template <typename T, DN_USize N>             DN_Slice<T>            DN_FArray_Slice                    (DN_FArray<T, N> const *array);
template <typename T, DN_USize N>             T *                    DN_FArray_AddArray                 (DN_FArray<T, N> *array, T const *items, DN_USize count);
template <typename T, DN_USize N, DN_USize K> T *                    DN_FArray_AddCArray                (DN_FArray<T, N> *array, T const (&items)[K]);
template <typename T, DN_USize N>             T *                    DN_FArray_Add                      (DN_FArray<T, N> *array, T const &item);
#define                                                              DN_FArray_AddArrayAssert(...)      DN_HARD_ASSERT(DN_FArray_AddArray(__VA_ARGS__))
#define                                                              DN_FArray_AddCArrayAssert(...)     DN_HARD_ASSERT(DN_FArray_AddCArray(__VA_ARGS__))
#define                                                              DN_FArray_AddAssert(...)           DN_HARD_ASSERT(DN_FArray_Add(__VA_ARGS__))
template <typename T, DN_USize N>              T *                   DN_FArray_MakeArray                (DN_FArray<T, N> *array, DN_USize count, DN_ZeroMem zero_mem);
template <typename T, DN_USize N>              T *                   DN_FArray_Make                     (DN_FArray<T, N> *array, DN_ZeroMem zero_mem);
#define                                                              DN_FArray_MakeArrayAssert(...)     DN_HARD_ASSERT(DN_FArray_MakeArray(__VA_ARGS__))
#define                                                              DN_FArray_MakeAssert(...)          DN_HARD_ASSERT(DN_FArray_Make(__VA_ARGS__))
template <typename T, DN_USize N>              T *                   DN_FArray_InsertArray              (DN_FArray<T, N> *array, T const &item, DN_USize index);
template <typename T, DN_USize N, DN_USize K> T *                    DN_FArray_InsertCArray             (DN_FArray<T, N> *array, DN_USize index, T const (&items)[K]);
template <typename T, DN_USize N>              T *                   DN_FArray_Insert                   (DN_FArray<T, N> *array, DN_USize index, T const &item);
#define                                                              DN_FArray_InsertArrayAssert(...)   DN_HARD_ASSERT(DN_FArray_InsertArray(__VA_ARGS__))
#define                                                              DN_FArray_InsertAssert(...)        DN_HARD_ASSERT(DN_FArray_Insert(__VA_ARGS__))
template <typename T, DN_USize N>              T                     DN_FArray_PopFront                 (DN_FArray<T, N> *array, DN_USize count);
template <typename T, DN_USize N>              T                     DN_FArray_PopBack                  (DN_FArray<T, N> *array, DN_USize count);
template <typename T, DN_USize N>              DN_ArrayFindResult<T> DN_FArray_Find                     (DN_FArray<T, N> *array, T const &find);
template <typename T, DN_USize N>              DN_ArrayEraseResult   DN_FArray_EraseRange               (DN_FArray<T, N> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
template <typename T, DN_USize N>              void                  DN_FArray_Clear                    (DN_FArray<T, N> *array);
#endif // !defined(DN_NO_FARRAY)
#if !defined(DN_NO_SLICE)
#define                                                               DN_TO_SLICE(val)                  DN_Slice_Init((val)->data, (val)->size)
template <typename T>                           DN_Slice<T>           DN_Slice_Init                     (T* const data, DN_USize size);
template <typename T, DN_USize N>               DN_Slice<T>           DN_Slice_InitCArray               (DN_Arena *arena, T const (&array)[N]);
template <typename T>                           DN_Slice<T>           DN_Slice_Copy                     (DN_Arena *arena, DN_Slice<T> slice);
template <typename T>                           DN_Slice<T>           DN_Slice_CopyPtr                  (DN_Arena *arena, T* const data, DN_USize size);
template <typename T>                           DN_Slice<T>           DN_Slice_Alloc                    (DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem);
                                                DN_Str8               DN_Slice_Str8Render               (DN_Arena *arena, DN_Slice<DN_Str8> array, DN_Str8 separator);
                                                DN_Str8               DN_Slice_Str8RenderSpaceSeparated (DN_Arena *arena, DN_Slice<DN_Str8> array);
                                                DN_Str16              DN_Slice_Str16Render              (DN_Arena *arena, DN_Slice<DN_Str16> array, DN_Str16 separator);
                                                DN_Str16              DN_Slice_Str16RenderSpaceSeparated(DN_Arena *arena, DN_Slice<DN_Str16> array);
#endif // !defined(DN_NO_SLICE)
#if !defined(DN_NO_DSMAP)
template <typename T>                           DN_DSMap<T>           DN_DSMap_Init                     (DN_Arena *arena, DN_U32 size, DN_DSMapFlags flags);
template <typename T>                           void                  DN_DSMap_Deinit                   (DN_DSMap<T> *map, DN_ZeroMem zero_mem);
template <typename T>                           bool                  DN_DSMap_IsValid                  (DN_DSMap<T> const *map);
template <typename T>                           DN_U32                DN_DSMap_Hash                     (DN_DSMap<T> const *map, DN_DSMapKey key);
template <typename T>                           DN_U32                DN_DSMap_HashToSlotIndex          (DN_DSMap<T> const *map, DN_DSMapKey key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_Find                     (DN_DSMap<T> const *map, DN_DSMapKey key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_Make                     (DN_DSMap<T> *map, DN_DSMapKey key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_Set                      (DN_DSMap<T> *map, DN_DSMapKey key, T const &value);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_FindKeyU64               (DN_DSMap<T> const *map, DN_U64 key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_MakeKeyU64               (DN_DSMap<T> *map,       DN_U64 key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_SetKeyU64                (DN_DSMap<T> *map,       DN_U64 key, T const &value);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_FindKeyStr8              (DN_DSMap<T> const *map, DN_Str8 key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_MakeKeyStr8              (DN_DSMap<T> *map,       DN_Str8 key);
template <typename T>                           DN_DSMapResult<T>     DN_DSMap_SetKeyStr8               (DN_DSMap<T> *map,       DN_Str8 key, T const &value);
template <typename T>                           bool                  DN_DSMap_Resize                   (DN_DSMap<T> *map, DN_U32 size);
template <typename T>                           bool                  DN_DSMap_Erase                    (DN_DSMap<T> *map, DN_DSMapKey key);
template <typename T>                           bool                  DN_DSMap_EraseKeyU64              (DN_DSMap<T> *map, DN_U64 key);
template <typename T>                           bool                  DN_DSMap_EraseKeyStr8             (DN_DSMap<T> *map, DN_Str8 key);
template <typename T>                           DN_DSMapKey           DN_DSMap_KeyBuffer                (DN_DSMap<T> const *map, void const *data, DN_U32 size);
template <typename T>                           DN_DSMapKey           DN_DSMap_KeyBufferAsU64NoHash     (DN_DSMap<T> const *map, void const *data, DN_U32 size);
template <typename T>                           DN_DSMapKey           DN_DSMap_KeyU64                   (DN_DSMap<T> const *map, DN_U64 u64);
template <typename T>                           DN_DSMapKey           DN_DSMap_KeyStr8                  (DN_DSMap<T> const *map, DN_Str8 string);
#define                                                               DN_DSMap_KeyCStr8(map, string)    DN_DSMap_KeyBuffer(map, string, sizeof((string))/sizeof((string)[0]) - 1)
DN_API                                          DN_DSMapKey           DN_DSMap_KeyU64NoHash             (DN_U64 u64);
DN_API                                          bool                  DN_DSMap_KeyEquals                (DN_DSMapKey lhs, DN_DSMapKey rhs);
DN_API                                          bool                  operator==                        (DN_DSMapKey lhs, DN_DSMapKey rhs);
#endif // !defined(DN_NO_DSMAP)
#if !defined(DN_NO_LIST)
template <typename T>                           DN_List<T>            DN_List_Init                      (DN_USize chunk_size);
template <typename T, size_t N>                 DN_List<T>            DN_List_InitCArray                (DN_Arena *arena, DN_USize chunk_size, T const (&array)[N]);
template <typename T>                           T *                   DN_List_At                        (DN_List<T> *list, DN_USize index, DN_ListChunk<T> **at_chunk);
template <typename T>                           void                  DN_List_Clear                     (DN_List<T> *list);
template <typename T>                           bool                  DN_List_Iterate                   (DN_List<T> *list, DN_ListIterator<T> *it, DN_USize start_index);
template <typename T>                           T *                   DN_List_MakeArena                 (DN_List<T> *list, DN_Arena *arena, DN_USize count);
template <typename T>                           T *                   DN_List_MakePool                  (DN_List<T> *list, DN_Pool *pool, DN_USize count);
template <typename T>                           T *                   DN_List_AddArena                  (DN_List<T> *list, DN_Arena *arena, T const &value);
template <typename T>                           T *                   DN_List_AddPool                   (DN_List<T> *list, DN_Pool *pool, T const &value);
template <typename T>                           void                  DN_List_AddListArena              (DN_List<T> *list, DN_Arena *arena, DN_List<T> other);
template <typename T>                           void                  DN_List_AddListArena              (DN_List<T> *list, DN_Pool *pool, DN_List<T> other);
template <typename T>                           DN_Slice<T>           DN_List_ToSliceCopy               (DN_List<T> const *list, DN_Arena* arena);
#endif // !defined(DN_NO_LIST)