private_array_adaptive_map.h File Reference

The Private Array Adaptive Map Types and Interface. More...

#include "../../types.h"

Include dependency graph for private_array_adaptive_map.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Detailed Description

The Private Array Adaptive Map Types and Interface.

The array adaptive map offers a struct-of-arrays layout for slightly better alignment and memory utilization. This also allows for index handle stability in contrast to pointer stability that the intrusive variant offers.

Data Structures
struct	CCC_Array_adaptive_map_node
struct	CCC_Array_adaptive_map
struct	CCC_Array_adaptive_map_handle

Macros
#define	CCC_private_array_adaptive_map_compound_literal_array_capacity( private_type_compound_literal_array)
#define	CCC_private_array_adaptive_map_default( private_type_name, private_key_node_field, private_comparator...)
#define	CCC_private_array_adaptive_map_for( private_type_name, private_key_field, private_comparator, private_capacity, private_memory_pointer)
#define	CCC_private_array_adaptive_map_from( private_key_field, private_comparator, private_allocator, private_optional_cap, private_array_compound_literal...)
#define	CCC_private_array_adaptive_map_with_capacity( private_type_name, private_key_field, private_comparator, private_allocator, private_cap)
#define	CCC_private_array_adaptive_map_storage_for( private_type_compound_literal_array, optional_storage_specifier...)
#define	CCC_private_array_adaptive_map_with_storage( private_key_node_field, private_comparator, private_compound_literal, private_optional_storage_specifier...)
#define	CCC_private_array_adaptive_map_with_allocator_storage( private_key_field, private_comparator, private_allocator, private_compound_literal)
#define	CCC_private_array_adaptive_map_as( array_adaptive_map_pointer, type_name, handle...)
#define	CCC_private_array_adaptive_map_and_modify_with( array_adaptive_map_handle_pointer, closure_parameter, closure_over_closure_parameter...)
#define	CCC_private_array_adaptive_map_or_insert_with( array_adaptive_map_handle_pointer, private_allocator_pointer, type_compound_literal...)
#define	CCC_private_array_adaptive_map_insert_handle_with( array_adaptive_map_handle_pointer, private_allocator_pointer, type_compound_literal...)
#define	CCC_private_array_adaptive_map_try_insert_with( array_adaptive_map_pointer, key, private_allocator_pointer, type_compound_literal...)
#define	CCC_private_array_adaptive_map_insert_or_assign_with( array_adaptive_map_pointer, key, private_allocator_pointer, type_compound_literal...)

Functions
void	CCC_private_array_adaptive_map_insert (struct CCC_Array_adaptive_map *, size_t)
struct CCC_Array_adaptive_map_handle	CCC_private_array_adaptive_map_handle (struct CCC_Array_adaptive_map *, void const *key)
void *	CCC_private_array_adaptive_map_data_at (struct CCC_Array_adaptive_map const *, size_t slot)
void *	CCC_private_array_adaptive_map_key_at (struct CCC_Array_adaptive_map const *, size_t slot)
size_t	CCC_private_array_adaptive_map_allocate_slot (struct CCC_Array_adaptive_map *, CCC_Allocator const *)

Macro Definition Documentation

CCC_private_array_adaptive_map_and_modify_with

#define CCC_private_array_adaptive_map_and_modify_with	(		array_adaptive_map_handle_pointer,
			closure_parameter,
			closure_over_closure_parameter...
	)

Value:

    (__extension__({                                                           \
        struct CCC_Array_adaptive_map_handle const *const                      \
            private_array_adaptive_map_mod_hndl_pointer                        \
            = (array_adaptive_map_handle_pointer);                             \
        struct CCC_Array_adaptive_map_handle                                   \
            private_array_adaptive_map_mod_hndl                                \
            = {.status = CCC_ENTRY_ARGUMENT_ERROR};                            \
        if (private_array_adaptive_map_mod_hndl_pointer) {                     \
            private_array_adaptive_map_mod_hndl                                \
                = *private_array_adaptive_map_mod_hndl_pointer;                \
            if (private_array_adaptive_map_mod_hndl.status                     \
                & CCC_ENTRY_OCCUPIED) {                                        \
                closure_parameter = CCC_private_array_adaptive_map_data_at(    \
                    private_array_adaptive_map_mod_hndl.map,                   \
                    private_array_adaptive_map_mod_hndl.index                  \
                );                                                             \
                closure_over_closure_parameter                                 \
            }                                                                  \
        }                                                                      \
        private_array_adaptive_map_mod_hndl;                                   \
    }))

CCC_private_array_adaptive_map_as

#define CCC_private_array_adaptive_map_as	(		array_adaptive_map_pointer,
			type_name,
			handle...
	)

Value:

    ((type_name *)CCC_private_array_adaptive_map_data_at(                      \
        (array_adaptive_map_pointer), (handle)                                 \
    ))

CCC_private_array_adaptive_map_compound_literal_array_capacity

#define CCC_private_array_adaptive_map_compound_literal_array_capacity

(

private_type_compound_literal_array

)

Value:

    (sizeof(private_type_compound_literal_array)                               \
     / sizeof(*(private_type_compound_literal_array)))

CCC_private_array_adaptive_map_default

#define CCC_private_array_adaptive_map_default	(		private_type_name,
			private_key_node_field,
			private_comparator...
	)

Value:

    (struct CCC_Array_adaptive_map) {                                          \
        .sizeof_type = sizeof(private_type_name),                              \
        .alignof_type = alignof(private_type_name),                            \
        .key_offset = offsetof(private_type_name, private_key_node_field),     \
        .comparator = private_comparator,                                      \
    }

All other fields default to NULL or 0.

CCC_private_array_adaptive_map_for

#define CCC_private_array_adaptive_map_for	(		private_type_name,
			private_key_field,
			private_comparator,
			private_capacity,
			private_memory_pointer
	)

Value:

    (struct CCC_Array_adaptive_map) {                                          \
        .data = (private_memory_pointer), .nodes = NULL,                       \
        .capacity = (private_capacity), .count = 0, .root = 0, .free_list = 0, \
        .sizeof_type = sizeof(private_type_name),                              \
        .alignof_type = alignof(private_type_name),                            \
        .key_offset = offsetof(private_type_name, private_key_field),          \
        .comparator = (private_comparator),                                    \
    }

CCC_private_array_adaptive_map_from

#define CCC_private_array_adaptive_map_from	(		private_key_field,
			private_comparator,
			private_allocator,
			private_optional_cap,
			private_array_compound_literal...
	)

Initialize an array adaptive map from user input list.

CCC_private_array_adaptive_map_insert_handle_with

#define CCC_private_array_adaptive_map_insert_handle_with	(		array_adaptive_map_handle_pointer,
			private_allocator_pointer,
			type_compound_literal...
	)

CCC_private_array_adaptive_map_insert_or_assign_with

#define CCC_private_array_adaptive_map_insert_or_assign_with	(		array_adaptive_map_pointer,
			key,
			private_allocator_pointer,
			type_compound_literal...
	)

CCC_private_array_adaptive_map_or_insert_with

#define CCC_private_array_adaptive_map_or_insert_with	(		array_adaptive_map_handle_pointer,
			private_allocator_pointer,
			type_compound_literal...
	)

CCC_private_array_adaptive_map_storage_for

#define CCC_private_array_adaptive_map_storage_for	(		private_type_compound_literal_array,
			optional_storage_specifier...
	)

Value:

    (optional_storage_specifier struct {                                       \
        static_assert(                                                         \
            CCC_private_array_adaptive_map_compound_literal_array_capacity(    \
                private_type_compound_literal_array                            \
            ) > 1,                                                             \
            "fixed size map must have capacity greater than 1"                 \
        );                                                                     \
        alignas(                                                               \
            alignof(*(private_type_compound_literal_array))                    \
                    > alignof(struct CCC_Array_adaptive_map_node)              \
                ? alignof(*(private_type_compound_literal_array))              \
                : alignof(struct CCC_Array_adaptive_map_node)                  \
        ) typeof(*(private_type_compound_literal_array)) data                  \
            [CCC_private_array_adaptive_map_compound_literal_array_capacity(   \
                private_type_compound_literal_array                            \
            )];                                                                \
        struct CCC_Array_adaptive_map_node nodes                               \
            [CCC_private_array_adaptive_map_compound_literal_array_capacity(   \
                private_type_compound_literal_array                            \
            )];                                                                \
    }) {                                                                       \
    }

The user can declare a fixed size realtime ordered map with the help of static asserts to ensure the layout is compatible with our internal metadata.

CCC_private_array_adaptive_map_try_insert_with

#define CCC_private_array_adaptive_map_try_insert_with	(		array_adaptive_map_pointer,
			key,
			private_allocator_pointer,
			type_compound_literal...
	)

CCC_private_array_adaptive_map_with_allocator_storage

#define CCC_private_array_adaptive_map_with_allocator_storage	(		private_key_field,
			private_comparator,
			private_allocator,
			private_compound_literal
	)

Helper for allocating a fixed size map dynamically.

CCC_private_array_adaptive_map_with_capacity

#define CCC_private_array_adaptive_map_with_capacity	(		private_type_name,
			private_key_field,
			private_comparator,
			private_allocator,
			private_cap
	)

Value:

    (struct { struct CCC_Array_adaptive_map private; }){(__extension__({       \
        struct CCC_Array_adaptive_map private_array_adaptive_map               \
            = CCC_private_array_adaptive_map_default(                          \
                private_type_name, private_key_field, private_comparator       \
            );                                                                 \
        (void)CCC_array_adaptive_map_reserve(                                  \
            &private_array_adaptive_map, private_cap, &(private_allocator)     \
        );                                                                     \
        private_array_adaptive_map;                                            \
    }))}.private

CCC_private_array_adaptive_map_with_storage

#define CCC_private_array_adaptive_map_with_storage	(		private_key_node_field,
			private_comparator,
			private_compound_literal,
			private_optional_storage_specifier...
	)

Value:

    (struct CCC_Array_adaptive_map) {                                          \
        .data = &CCC_private_array_adaptive_map_storage_for(                   \
            private_compound_literal, private_optional_storage_specifier       \
        ),                                                                     \
        .nodes = NULL,                                                         \
        .capacity                                                              \
            = CCC_private_array_adaptive_map_compound_literal_array_capacity(  \
                private_compound_literal                                       \
            ),                                                                 \
        .count = 0, .root = 0, .free_list = 0,                                 \
        .sizeof_type = sizeof(*(private_compound_literal)),                    \
        .alignof_type = alignof(*(private_compound_literal)),                  \
        .key_offset = offsetof(                                                \
            typeof(*(private_compound_literal)), private_key_node_field        \
        ),                                                                     \
        .comparator = (private_comparator),                                    \
    }

Function Documentation

CCC_private_array_adaptive_map_allocate_slot()

size_t CCC_private_array_adaptive_map_allocate_slot	(	struct CCC_Array_adaptive_map *	,
		CCC_Allocator const *
	)

CCC_private_array_adaptive_map_data_at()

void * CCC_private_array_adaptive_map_data_at	(	struct CCC_Array_adaptive_map const *	,
		size_t	slot
	)

CCC_private_array_adaptive_map_handle()

struct CCC_Array_adaptive_map_handle CCC_private_array_adaptive_map_handle	(	struct CCC_Array_adaptive_map *	,
		void const *	key
	)

CCC_private_array_adaptive_map_insert()

void CCC_private_array_adaptive_map_insert	(	struct CCC_Array_adaptive_map *	,
		size_t
	)

CCC_private_array_adaptive_map_key_at()

void * CCC_private_array_adaptive_map_key_at	(	struct CCC_Array_adaptive_map const *	,
		size_t	slot
	)