array_adaptive_map.h

Go to the documentation of this file.

 
#ifndef CCC_ARRAY_ADAPTIVE_MAP_H
#define CCC_ARRAY_ADAPTIVE_MAP_H
 
#include <stddef.h>
#include "../types.h" /* IWYU pragma: export */
#include "private/private_array_adaptive_map.h"
 
typedef struct CCC_Array_adaptive_map CCC_Array_adaptive_map;
 
typedef struct CCC_Array_adaptive_map_handle CCC_Array_adaptive_map_handle;
 
#define CCC_array_adaptive_map_storage_for(                                    \
    user_type_compound_literal_array, optional_storage_specifier...            \
)                                                                              \
    CCC_private_array_adaptive_map_storage_for(                                \
        user_type_compound_literal_array, optional_storage_specifier           \
    )
 
#define CCC_array_adaptive_map_default(                                        \
    type_name, type_key_field, comparator...                                   \
)                                                                              \
    CCC_private_array_adaptive_map_default(                                    \
        type_name, type_key_field, comparator                                  \
    )
 
#define CCC_array_adaptive_map_for(                                            \
    type_name, type_key_field, comparator, capacity, memory_pointer            \
)                                                                              \
    CCC_private_array_adaptive_map_for(                                        \
        type_name, type_key_field, comparator, capacity, memory_pointer        \
    )
 
#define CCC_array_adaptive_map_from(                                           \
    type_key_field,                                                            \
    comparator,                                                                \
    allocator,                                                                 \
    optional_capacity,                                                         \
    type_compound_literal_array...                                             \
)                                                                              \
    CCC_private_array_adaptive_map_from(                                       \
        type_key_field,                                                        \
        comparator,                                                            \
        allocator,                                                             \
        optional_capacity,                                                     \
        type_compound_literal_array                                            \
    )
 
#define CCC_array_adaptive_map_with_capacity(                                  \
    type_name, type_key_field, comparator, allocator, capacity                 \
)                                                                              \
    CCC_private_array_adaptive_map_with_capacity(                              \
        type_name, type_key_field, comparator, allocator, capacity             \
    )
 
#define CCC_array_adaptive_map_with_storage(                                   \
    type_key_field,                                                            \
    comparator,                                                                \
    compound_literal,                                                          \
    optional_storage_specifier...                                              \
)                                                                              \
    CCC_private_array_adaptive_map_with_storage(                               \
        type_key_field,                                                        \
        comparator,                                                            \
        compound_literal,                                                      \
        optional_storage_specifier                                             \
    )
 
#define CCC_array_adaptive_map_with_allocator_storage(                         \
    key_field, comparator, allocator, compound_literal                         \
)                                                                              \
    CCC_private_array_adaptive_map_with_allocator_storage(                     \
        key_field, comparator, allocator, compound_literal                     \
    )
 
CCC_Result CCC_array_adaptive_map_copy(
    CCC_Array_adaptive_map *destination,
    CCC_Array_adaptive_map const *source,
    CCC_Allocator const *allocator
);
 
CCC_Result CCC_array_adaptive_map_reserve(
    CCC_Array_adaptive_map *map, size_t to_add, CCC_Allocator const *allocator
);
 
[[nodiscard]] void *CCC_array_adaptive_map_at(
    CCC_Array_adaptive_map const *map, CCC_Handle_index index
);
 
#define CCC_array_adaptive_map_as(map_pointer, type_name, array_index...)      \
    CCC_private_array_adaptive_map_as(map_pointer, type_name, array_index)
 
[[nodiscard]] CCC_Tribool
CCC_array_adaptive_map_contains(CCC_Array_adaptive_map *map, void const *key);
 
[[nodiscard]] CCC_Handle_index CCC_array_adaptive_map_get_key_value(
    CCC_Array_adaptive_map *map, void const *key
);
 
[[nodiscard]] CCC_Handle CCC_array_adaptive_map_swap_handle(
    CCC_Array_adaptive_map *map,
    void *type_output,
    CCC_Allocator const *allocator
);
 
#define CCC_array_adaptive_map_swap_handle_wrap(                               \
    map_pointer, type_output_pointer, allocator_pointer...                     \
)                                                                              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_array_adaptive_map_swap_handle(                                    \
            (map_pointer), (type_output_pointer), allocator_pointer            \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle CCC_array_adaptive_map_try_insert(
    CCC_Array_adaptive_map *map,
    void const *type,
    CCC_Allocator const *allocator
);
 
#define CCC_array_adaptive_map_try_insert_wrap(                                \
    map_pointer, type_pointer, allocator_pointer...                            \
)                                                                              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_array_adaptive_map_try_insert(                                     \
            (map_pointer), (type_pointer), allocator_pointer                   \
        )}                                                                     \
         .private
 
#define CCC_array_adaptive_map_try_insert_with(                                \
    map_pointer, key, allocator_pointer, type_compound_literal...              \
)                                                                              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_private_array_adaptive_map_try_insert_with(                        \
            map_pointer, key, allocator_pointer, type_compound_literal         \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle CCC_array_adaptive_map_insert_or_assign(
    CCC_Array_adaptive_map *map,
    void const *type,
    CCC_Allocator const *allocator
);
 
#define CCC_array_adaptive_map_insert_or_assign_wrap(                          \
    map_pointer, type_pointer, allocator_pointer...                            \
)                                                                              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_array_adaptive_map_insert_or_assign(                               \
            (map_pointer), (type_pointer), allocator_pointer                   \
        )}                                                                     \
         .private
 
#define CCC_array_adaptive_map_insert_or_assign_with(                          \
    map_pointer, key, allocator_pointer, type_compound_literal...              \
)                                                                              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_private_array_adaptive_map_insert_or_assign_with(                  \
            map_pointer, key, allocator_pointer, type_compound_literal         \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle CCC_array_adaptive_map_remove_key_value(
    CCC_Array_adaptive_map *map, void *type_output
);
 
#define CCC_array_adaptive_map_remove_key_value_wrap(                          \
    map_pointer, type_output_pointer                                           \
)                                                                              \
    &(struct { CCC_Handle private; }){CCC_array_adaptive_map_remove_key_value( \
                                          (map_pointer), (type_output_pointer) \
                                      )}                                       \
         .private
 
[[nodiscard]] CCC_Array_adaptive_map_handle
CCC_array_adaptive_map_handle(CCC_Array_adaptive_map *map, void const *key);
 
#define CCC_array_adaptive_map_handle_wrap(handle_pointer, key_pointer)        \
    &(struct { CCC_Array_adaptive_map_handle private; }){                      \
        CCC_array_adaptive_map_handle((handle_pointer), (key_pointer))}        \
         .private
 
[[nodiscard]] CCC_Array_adaptive_map_handle *CCC_array_adaptive_map_and_modify(
    CCC_Array_adaptive_map_handle *handle, CCC_Modifier const *modifier
);
 
#define CCC_array_adaptive_map_and_modify_with(                                \
    handle_pointer, closure_parameter, closure_over_closure_parameter...       \
)                                                                              \
    &(struct { CCC_Array_adaptive_map_handle private; }){                      \
        CCC_private_array_adaptive_map_and_modify_with(                        \
            handle_pointer, closure_parameter, closure_over_closure_parameter  \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle_index CCC_array_adaptive_map_or_insert(
    CCC_Array_adaptive_map_handle const *handle,
    void const *type,
    CCC_Allocator const *allocator
);
 
#define CCC_array_adaptive_map_or_insert_with(                                 \
    handle_pointer, allocator_pointer, type_compound_literal...                \
)                                                                              \
    CCC_private_array_adaptive_map_or_insert_with(                             \
        handle_pointer, allocator_pointer, type_compound_literal               \
    )
 
[[nodiscard]] CCC_Handle_index CCC_array_adaptive_map_insert_handle(
    CCC_Array_adaptive_map_handle const *handle,
    void const *type,
    CCC_Allocator const *allocator
);
 
#define CCC_array_adaptive_map_insert_handle_with(                             \
    handle_pointer, allocator_pointer, type_compound_literal...                \
)                                                                              \
    CCC_private_array_adaptive_map_insert_handle_with(                         \
        handle_pointer, allocator_pointer, type_compound_literal               \
    )
 
[[nodiscard]] CCC_Handle
CCC_array_adaptive_map_remove_handle(CCC_Array_adaptive_map_handle *handle);
 
#define CCC_array_adaptive_map_remove_handle_wrap(handle_pointer)              \
    &(struct { CCC_Handle private; }){                                         \
        CCC_array_adaptive_map_remove_handle((handle_pointer))}                \
         .private
 
[[nodiscard]] CCC_Handle_index
CCC_array_adaptive_map_unwrap(CCC_Array_adaptive_map_handle const *handle);
 
[[nodiscard]] CCC_Tribool
CCC_array_adaptive_map_occupied(CCC_Array_adaptive_map_handle const *handle);
 
[[nodiscard]] CCC_Tribool CCC_array_adaptive_map_insert_error(
    CCC_Array_adaptive_map_handle const *handle
);
 
[[nodiscard]] CCC_Handle_status CCC_array_adaptive_map_handle_status(
    CCC_Array_adaptive_map_handle const *handle
);
 
[[nodiscard]] CCC_Handle_range CCC_array_adaptive_map_equal_range(
    CCC_Array_adaptive_map *map, void const *begin_key, void const *end_key
);
 
#define CCC_array_adaptive_map_equal_range_wrap(                               \
    map_pointer, begin_and_end_key_pointers...                                 \
)                                                                              \
    &(struct { CCC_Handle_range private; }){                                   \
        CCC_array_adaptive_map_equal_range(                                    \
            map_pointer, begin_and_end_key_pointers                            \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle_range_reverse
CCC_array_adaptive_map_equal_range_reverse(
    CCC_Array_adaptive_map *map,
    void const *reverse_begin_key,
    void const *reverse_end_key
);
 
#define CCC_array_adaptive_map_equal_range_reverse_wrap(                       \
    map_pointer, reverse_begin_and_reverse_end_key_pointers...                 \
)                                                                              \
    &(struct { CCC_Handle_range_reverse private; }){                           \
        CCC_array_adaptive_map_equal_range_reverse(                            \
            map_pointer, reverse_begin_and_reverse_end_key_pointers            \
        )}                                                                     \
         .private
 
[[nodiscard]] CCC_Handle_index
CCC_array_adaptive_map_begin(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Handle_index
CCC_array_adaptive_map_reverse_begin(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Handle_index CCC_array_adaptive_map_next(
    CCC_Array_adaptive_map const *map, CCC_Handle_index iterator
);
 
[[nodiscard]] CCC_Handle_index CCC_array_adaptive_map_reverse_next(
    CCC_Array_adaptive_map const *map, CCC_Handle_index iterator
);
 
[[nodiscard]] CCC_Handle_index
CCC_array_adaptive_map_end(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Handle_index
CCC_array_adaptive_map_reverse_end(CCC_Array_adaptive_map const *map);
 
CCC_Result CCC_array_adaptive_map_clear(
    CCC_Array_adaptive_map *map, CCC_Destructor const *destructor
);
 
CCC_Result CCC_array_adaptive_map_clear_and_free(
    CCC_Array_adaptive_map *map,
    CCC_Destructor const *destructor,
    CCC_Allocator const *allocator
);
 
[[nodiscard]] CCC_Count
CCC_array_adaptive_map_count(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Count
CCC_array_adaptive_map_capacity(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Tribool
CCC_array_adaptive_map_is_empty(CCC_Array_adaptive_map const *map);
 
[[nodiscard]] CCC_Tribool
CCC_array_adaptive_map_validate(CCC_Array_adaptive_map const *map);
 
#ifdef ARRAY_ADAPTIVE_MAP_USING_NAMESPACE_CCC
/* NOLINTBEGIN(readability-identifier-naming) */
typedef CCC_Array_adaptive_map Array_adaptive_map;
typedef CCC_Array_adaptive_map_handle Array_adaptive_map_handle;
#    define array_adaptive_map_storage_for(arguments...)                       \
        CCC_array_adaptive_map_storage_for(arguments)
#    define array_adaptive_map_default(arguments...)                           \
        CCC_array_adaptive_map_default(arguments)
#    define array_adaptive_map_for(arguments...)                               \
        CCC_array_adaptive_map_for(arguments)
#    define array_adaptive_map_from(arguments...)                              \
        CCC_array_adaptive_map_from(arguments)
#    define array_adaptive_map_with_capacity(arguments...)                     \
        CCC_array_adaptive_map_with_capacity(arguments)
#    define array_adaptive_map_with_storage(arguments...)                      \
        CCC_array_adaptive_map_with_storage(arguments)
#    define array_adaptive_map_with_allocator_storage(arguments...)            \
        CCC_array_adaptive_map_with_allocator_storage(arguments)
#    define array_adaptive_map_at(arguments...)                                \
        CCC_array_adaptive_map_at(arguments)
#    define array_adaptive_map_as(arguments...)                                \
        CCC_array_adaptive_map_as(arguments)
#    define array_adaptive_map_and_modify_with(arguments...)                   \
        CCC_array_adaptive_map_and_modify_with(arguments)
#    define array_adaptive_map_or_insert_with(arguments...)                    \
        CCC_array_adaptive_map_or_insert_with(arguments)
#    define array_adaptive_map_insert_handle_with(arguments...)                \
        CCC_array_adaptive_map_insert_handle_with(arguments)
#    define array_adaptive_map_try_insert_with(arguments...)                   \
        CCC_array_adaptive_map_try_insert_with(arguments)
#    define array_adaptive_map_copy(arguments...)                              \
        CCC_array_adaptive_map_copy(arguments)
#    define array_adaptive_map_reserve(arguments...)                           \
        CCC_array_adaptive_map_reserve(arguments)
#    define array_adaptive_map_contains(arguments...)                          \
        CCC_array_adaptive_map_contains(arguments)
#    define array_adaptive_map_get_key_value(arguments...)                     \
        CCC_array_adaptive_map_get_key_value(arguments)
#    define array_adaptive_map_swap_handle_wrap(arguments...)                  \
        CCC_array_adaptive_map_swap_handle_wrap(arguments)
#    define array_adaptive_map_try_insert_wrap(arguments...)                   \
        CCC_array_adaptive_map_try_insert_wrap(arguments)
#    define array_adaptive_map_remove_key_value_wrap(arguments...)             \
        CCC_array_adaptive_map_remove_key_value_wrap(arguments)
#    define array_adaptive_map_remove_handle_wrap(arguments...)                \
        CCC_array_adaptive_map_remove_handle_wrap(arguments)
#    define array_adaptive_map_swap_handle(arguments...)                       \
        CCC_array_adaptive_map_swap_handle(arguments)
#    define array_adaptive_map_try_insert(arguments...)                        \
        CCC_array_adaptive_map_try_insert(arguments)
#    define array_adaptive_map_insert_or_assign(arguments...)                  \
        CCC_array_adaptive_map_insert_or_assign(arguments)
#    define array_adaptive_map_insert_or_assign_wrap(arguments...)             \
        CCC_array_adaptive_map_insert_or_assign_wrap(arguments)
#    define array_adaptive_map_insert_or_assign_with(arguments...)             \
        CCC_array_adaptive_map_insert_or_assign_with(arguments)
#    define array_adaptive_map_remove_key_value(arguments...)                  \
        CCC_array_adaptive_map_remove_key_value(arguments)
#    define array_adaptive_map_remove_handle(arguments...)                     \
        CCC_array_adaptive_map_remove_handle(arguments)
#    define array_adaptive_map_handle_wrap(arguments...)                       \
        CCC_array_adaptive_map_handle_wrap(arguments)
#    define array_adaptive_map_handle(arguments...)                            \
        CCC_array_adaptive_map_handle(arguments)
#    define array_adaptive_map_and_modify(arguments...)                        \
        CCC_array_adaptive_map_and_modify(arguments)
#    define array_adaptive_map_or_insert(arguments...)                         \
        CCC_array_adaptive_map_or_insert(arguments)
#    define array_adaptive_map_insert_handle(arguments...)                     \
        CCC_array_adaptive_map_insert_handle(arguments)
#    define array_adaptive_map_unwrap(arguments...)                            \
        CCC_array_adaptive_map_unwrap(arguments)
#    define array_adaptive_map_insert_error(arguments...)                      \
        CCC_array_adaptive_map_insert_error(arguments)
#    define array_adaptive_map_handle_status(arguments...)                     \
        CCC_array_adaptive_map_handle_status(arguments)
#    define array_adaptive_map_occupied(arguments...)                          \
        CCC_array_adaptive_map_occupied(arguments)
#    define array_adaptive_map_clear(arguments...)                             \
        CCC_array_adaptive_map_clear(arguments)
#    define array_adaptive_map_clear_and_free(arguments...)                    \
        CCC_array_adaptive_map_clear_and_free(arguments)
#    define array_adaptive_map_begin(arguments...)                             \
        CCC_array_adaptive_map_begin(arguments)
#    define array_adaptive_map_reverse_begin(arguments...)                     \
        CCC_array_adaptive_map_reverse_begin(arguments)
#    define array_adaptive_map_end(arguments...)                               \
        CCC_array_adaptive_map_end(arguments)
#    define array_adaptive_map_reverse_end(arguments...)                       \
        CCC_array_adaptive_map_reverse_end(arguments)
#    define array_adaptive_map_next(arguments...)                              \
        CCC_array_adaptive_map_next(arguments)
#    define array_adaptive_map_reverse_next(arguments...)                      \
        CCC_array_adaptive_map_reverse_next(arguments)
#    define array_adaptive_map_equal_range(arguments...)                       \
        CCC_array_adaptive_map_equal_range(arguments)
#    define array_adaptive_map_equal_range_wrap(arguments...)                  \
        CCC_array_adaptive_map_equal_range_wrap(arguments)
#    define array_adaptive_map_equal_range_reverse(arguments...)               \
        CCC_array_adaptive_map_equal_range_reverse(arguments)
#    define array_adaptive_map_equal_range_reverse_wrap(arguments...)          \
        CCC_array_adaptive_map_equal_range_reverse_wrap(arguments)
#    define array_adaptive_map_count(arguments...)                             \
        CCC_array_adaptive_map_count(arguments)
#    define array_adaptive_map_capacity(arguments...)                          \
        CCC_array_adaptive_map_capacity(arguments)
#    define array_adaptive_map_is_empty(arguments...)                          \
        CCC_array_adaptive_map_is_empty(arguments)
#    define array_adaptive_map_validate(arguments...)                          \
        CCC_array_adaptive_map_validate(arguments)
/* NOLINTEND(readability-identifier-naming) */
#endif /* ARRAY_ADAPTIVE_MAP_USING_NAMESPACE_CCC */
 
#endif /* CCC_ARRAY_ADAPTIVE_MAP_H */