From 1f099bf17050f8b7783804b9adf404e6b43a0d4a Mon Sep 17 00:00:00 2001 From: Alexander Lopez Date: Mon, 19 Jan 2026 09:48:27 -0800 Subject: [PATCH] eliminate args abbreviation from headers --- README.md | 12 +- ccc/adaptive_map.h | 110 ++++++----- ccc/array_adaptive_map.h | 187 +++++++++--------- ccc/array_tree_map.h | 112 ++++++----- ccc/bitset.h | 168 ++++++++-------- ccc/buffer.h | 103 +++++----- ccc/doubly_linked_list.h | 110 ++++++----- ccc/flat_double_ended_queue.h | 116 +++++------ ccc/flat_hash_map.h | 151 +++++++------- ccc/flat_priority_queue.h | 125 ++++++------ ccc/priority_queue.h | 57 +++--- ccc/private/private_traits.h | 67 +++---- ccc/singly_linked_list.h | 87 ++++---- ccc/traits.h | 360 ++++++++++++++++++---------------- ccc/tree_map.h | 99 +++++----- tests/checkers.h | 4 +- 16 files changed, 989 insertions(+), 879 deletions(-) diff --git a/README.md b/README.md index 5a4dcd39..ae4f0f63 100644 --- a/README.md +++ b/README.md @@ -1084,9 +1084,9 @@ Rust has solid interfaces for associative containers, largely due to the Entry I - `CCC_Entry(container_pointer, key_pointer...)` - Obtains an entry, a view into an Occupied or Vacant user type stored in the container. - `CCC_and_modify(entry_pointer, mod_fn)` - Modify an occupied entry with a callback. -- `CCC_and_modify_context(entry_pointer, mod_fn, context_args)` - Modify an Occupied entry with a callback that requires context data. -- `CCC_or_insert(entry_pointer, or_insert_args)` - Insert a default key value if Vacant or return the Occupied entry. -- `CCC_insert_entry(entry_pointer, insert_entry_args)` - Invariantly insert a new key value, overwriting an Occupied entry if needed. +- `CCC_and_modify_context(entry_pointer, mod_fn, context_arguments)` - Modify an Occupied entry with a callback that requires context data. +- `CCC_or_insert(entry_pointer, or_insert_arguments)` - Insert a default key value if Vacant or return the Occupied entry. +- `CCC_insert_entry(entry_pointer, insert_entry_arguments)` - Invariantly insert a new key value, overwriting an Occupied entry if needed. - `CCC_remove_entry(entry_pointer)` - Remove an Occupied entry from the container or do nothing. Other Rust Interface functions like `get_key_value`, `insert`, and `remove` are included and can provide information about previous values stored in the container. @@ -1113,8 +1113,8 @@ This is possible because of the details discussed in the previous section. Conta Some C++ associative container interfaces have also been adapted to the Entry Interface. -- `CCC_try_insert(container_pointer, try_insert_args)` - Inserts a new element if none was present and reports if a previous entry existed. -- `CCC_insert_or_assign(container_pointer, insert_or_assign_args)` - Inserts a new element invariantly and reports if a previous entry existed. +- `CCC_try_insert(container_pointer, try_insert_arguments)` - Inserts a new element if none was present and reports if a previous entry existed. +- `CCC_insert_or_assign(container_pointer, insert_or_assign_arguments)` - Inserts a new element invariantly and reports if a previous entry existed. Many other containers fall back to C++ style interfaces when it makes sense to do so. @@ -1175,7 +1175,7 @@ The same insertion with the "with" variant. static inline struct Val val(int val_arg) { - return (struct Val){.val = val_args}; + return (struct Val){.val = val_arguments}; } CCC_Entry *e = adaptive_map_try_insert_with(&om, 3, val(1)); diff --git a/ccc/adaptive_map.h b/ccc/adaptive_map.h index b16fe585..6fd80dce 100644 --- a/ccc/adaptive_map.h +++ b/ccc/adaptive_map.h @@ -727,56 +727,66 @@ CCC_adaptive_map_validate(CCC_Adaptive_map const *map); typedef CCC_Adaptive_map_node Adaptive_map_node; typedef CCC_Adaptive_map Adaptive_map; typedef CCC_Adaptive_map_entry Adaptive_map_entry; -# define adaptive_map_initialize(args...) CCC_adaptive_map_initialize(args) -# define adaptive_map_from(args...) CCC_adaptive_map_from(args) -# define adaptive_map_and_modify_with(args...) \ - CCC_adaptive_map_and_modify_with(args) -# define adaptive_map_or_insert_with(args...) \ - CCC_adaptive_map_or_insert_with(args) -# define adaptive_map_insert_entry_with(args...) \ - CCC_adaptive_map_insert_entry_with(args) -# define adaptive_map_try_insert_with(args...) \ - CCC_adaptive_map_try_insert_with(args) -# define adaptive_map_insert_or_assign_with(args...) \ - CCC_adaptive_map_insert_or_assign_with(args) -# define adaptive_map_swap_entry_wrap(args...) \ - CCC_adaptive_map_swap_entry_wrap(args) -# define adaptive_map_remove_key_value_wrap(args...) \ - CCC_adaptive_map_remove_key_value_wrap(args) -# define adaptive_map_remove_entry_wrap(args...) \ - CCC_adaptive_map_remove_entry_wrap(args) -# define adaptive_map_entry_wrap(args...) CCC_adaptive_map_entry_wrap(args) -# define adaptive_map_and_modify_wrap(args...) \ - CCC_adaptive_map_and_modify_wrap(args) -# define adaptive_map_and_modify_context_wrap(args...) \ - CCC_adaptive_map_and_modify_context_wrap(args) -# define adaptive_map_contains(args...) CCC_adaptive_map_contains(args) -# define adaptive_map_get_key_value(args...) \ - CCC_adaptive_map_get_key_value(args) -# define adaptive_map_get_mut(args...) CCC_adaptive_map_get_mut(args) -# define adaptive_map_swap_entry(args...) CCC_adaptive_map_swap_entry(args) -# define adaptive_map_remove_key_value(args...) \ - CCC_adaptive_map_remove_key_value(args) -# define adaptive_map_entry(args...) CCC_adaptive_map_entry(args) -# define adaptive_map_remove_entry(args...) \ - CCC_adaptive_map_remove_entry(args) -# define adaptive_map_or_insert(args...) CCC_adaptive_map_or_insert(args) -# define adaptive_map_insert_entry(args...) \ - CCC_adaptive_map_insert_entry(args) -# define adaptive_map_unwrap(args...) CCC_adaptive_map_unwrap(args) -# define adaptive_map_unwrap_mut(args...) CCC_adaptive_map_unwrap_mut(args) -# define adaptive_map_begin(args...) CCC_adaptive_map_begin(args) -# define adaptive_map_next(args...) CCC_adaptive_map_next(args) -# define adaptive_map_reverse_begin(args...) \ - CCC_adaptive_map_reverse_begin(args) -# define adaptive_map_reverse_next(args...) \ - CCC_adaptive_map_reverse_next(args) -# define adaptive_map_end(args...) CCC_adaptive_map_end(args) -# define adaptive_map_reverse_end(args...) CCC_adaptive_map_reverse_end(args) -# define adaptive_map_count(args...) CCC_adaptive_map_count(args) -# define adaptive_map_is_empty(args...) CCC_adaptive_map_is_empty(args) -# define adaptive_map_clear(args...) CCC_adaptive_map_clear(args) -# define adaptive_map_validate(args...) CCC_adaptive_map_validate(args) +# define adaptive_map_initialize(arguments...) \ + CCC_adaptive_map_initialize(arguments) +# define adaptive_map_from(arguments...) CCC_adaptive_map_from(arguments) +# define adaptive_map_and_modify_with(arguments...) \ + CCC_adaptive_map_and_modify_with(arguments) +# define adaptive_map_or_insert_with(arguments...) \ + CCC_adaptive_map_or_insert_with(arguments) +# define adaptive_map_insert_entry_with(arguments...) \ + CCC_adaptive_map_insert_entry_with(arguments) +# define adaptive_map_try_insert_with(arguments...) \ + CCC_adaptive_map_try_insert_with(arguments) +# define adaptive_map_insert_or_assign_with(arguments...) \ + CCC_adaptive_map_insert_or_assign_with(arguments) +# define adaptive_map_swap_entry_wrap(arguments...) \ + CCC_adaptive_map_swap_entry_wrap(arguments) +# define adaptive_map_remove_key_value_wrap(arguments...) \ + CCC_adaptive_map_remove_key_value_wrap(arguments) +# define adaptive_map_remove_entry_wrap(arguments...) \ + CCC_adaptive_map_remove_entry_wrap(arguments) +# define adaptive_map_entry_wrap(arguments...) \ + CCC_adaptive_map_entry_wrap(arguments) +# define adaptive_map_and_modify_wrap(arguments...) \ + CCC_adaptive_map_and_modify_wrap(arguments) +# define adaptive_map_and_modify_context_wrap(arguments...) \ + CCC_adaptive_map_and_modify_context_wrap(arguments) +# define adaptive_map_contains(arguments...) \ + CCC_adaptive_map_contains(arguments) +# define adaptive_map_get_key_value(arguments...) \ + CCC_adaptive_map_get_key_value(arguments) +# define adaptive_map_get_mut(arguments...) \ + CCC_adaptive_map_get_mut(arguments) +# define adaptive_map_swap_entry(arguments...) \ + CCC_adaptive_map_swap_entry(arguments) +# define adaptive_map_remove_key_value(arguments...) \ + CCC_adaptive_map_remove_key_value(arguments) +# define adaptive_map_entry(arguments...) CCC_adaptive_map_entry(arguments) +# define adaptive_map_remove_entry(arguments...) \ + CCC_adaptive_map_remove_entry(arguments) +# define adaptive_map_or_insert(arguments...) \ + CCC_adaptive_map_or_insert(arguments) +# define adaptive_map_insert_entry(arguments...) \ + CCC_adaptive_map_insert_entry(arguments) +# define adaptive_map_unwrap(arguments...) CCC_adaptive_map_unwrap(arguments) +# define adaptive_map_unwrap_mut(arguments...) \ + CCC_adaptive_map_unwrap_mut(arguments) +# define adaptive_map_begin(arguments...) CCC_adaptive_map_begin(arguments) +# define adaptive_map_next(arguments...) CCC_adaptive_map_next(arguments) +# define adaptive_map_reverse_begin(arguments...) \ + CCC_adaptive_map_reverse_begin(arguments) +# define adaptive_map_reverse_next(arguments...) \ + CCC_adaptive_map_reverse_next(arguments) +# define adaptive_map_end(arguments...) CCC_adaptive_map_end(arguments) +# define adaptive_map_reverse_end(arguments...) \ + CCC_adaptive_map_reverse_end(arguments) +# define adaptive_map_count(arguments...) CCC_adaptive_map_count(arguments) +# define adaptive_map_is_empty(arguments...) \ + CCC_adaptive_map_is_empty(arguments) +# define adaptive_map_clear(arguments...) CCC_adaptive_map_clear(arguments) +# define adaptive_map_validate(arguments...) \ + CCC_adaptive_map_validate(arguments) #endif #endif /* CCC_ADAPTIVE_MAP_H */ diff --git a/ccc/array_adaptive_map.h b/ccc/array_adaptive_map.h index 8d1a47c5..d2f32ca7 100644 --- a/ccc/array_adaptive_map.h +++ b/ccc/array_adaptive_map.h @@ -1155,95 +1155,104 @@ CCC_array_adaptive_map_validate(CCC_Array_adaptive_map const *map); #ifdef ARRAY_ADAPTIVE_MAP_USING_NAMESPACE_CCC typedef CCC_Array_adaptive_map Array_adaptive_map; typedef CCC_Array_adaptive_map_handle Array_adaptive_map_handle; -# define array_adaptive_map_declare_fixed(args...) \ - CCC_array_adaptive_map_declare_fixed(args) -# define array_adaptive_map_fixed_capacity(args...) \ - CCC_array_adaptive_map_fixed_capacity(args) -# define array_adaptive_map_initialize(args...) \ - CCC_array_adaptive_map_initialize(args) -# define array_adaptive_map_from(args...) CCC_array_adaptive_map_from(args) -# define array_adaptive_map_with_capacity(args...) \ - CCC_array_adaptive_map_with_capacity(args) -# define array_adaptive_map_with_compound_literal(args...) \ - CCC_array_adaptive_map_with_compound_literal(args) -# define array_adaptive_map_with_context_compound_literal(args...) \ - CCC_array_adaptive_map_with_context_compound_literal(args) -# define array_adaptive_map_at(args...) CCC_array_adaptive_map_at(args) -# define array_adaptive_map_as(args...) CCC_array_adaptive_map_as(args) -# define array_adaptive_map_and_modify_with(args...) \ - CCC_array_adaptive_map_and_modify_with(args) -# define array_adaptive_map_or_insert_with(args...) \ - CCC_array_adaptive_map_or_insert_with(args) -# define array_adaptive_map_insert_array_with(args...) \ - CCC_array_adaptive_map_insert_array_with(args) -# define array_adaptive_map_try_insert_with(args...) \ - CCC_array_adaptive_map_try_insert_with(args) -# define array_adaptive_map_insert_or_assign_with(args...) \ - CCC_array_adaptive_map_insert_or_assign_with(args) -# define array_adaptive_map_copy(args...) CCC_array_adaptive_map_copy(args) -# define array_adaptive_map_reserve(args...) \ - CCC_array_adaptive_map_reserve(args) -# define array_adaptive_map_contains(args...) \ - CCC_array_adaptive_map_contains(args) -# define array_adaptive_map_get_key_value(args...) \ - CCC_array_adaptive_map_get_key_value(args) -# define array_adaptive_map_swap_handle_wrap(args...) \ - CCC_array_adaptive_map_swap_handle_wrap(args) -# define array_adaptive_map_try_insert_wrap(args...) \ - CCC_array_adaptive_map_try_insert_wrap(args) -# define array_adaptive_map_remove_key_value_wrap(args...) \ - CCC_array_adaptive_map_remove_key_value_wrap(args) -# define array_adaptive_map_remove_handle_wrap(args...) \ - CCC_array_adaptive_map_remove_handle_wrap(args) -# define array_adaptive_map_swap_handle(args...) \ - CCC_array_adaptive_map_swap_handle(args) -# define array_adaptive_map_try_insert(args...) \ - CCC_array_adaptive_map_try_insert(args) -# define array_adaptive_map_insert_or_assign(args...) \ - CCC_array_adaptive_map_insert_or_assign(args) -# define array_adaptive_map_remove_key_value(args...) \ - CCC_array_adaptive_map_remove_key_value(args) -# define array_adaptive_map_remove_handle(args...) \ - CCC_array_adaptive_map_remove_handle(args) -# define array_adaptive_map_handle_wrap(args...) \ - CCC_array_adaptive_map_handle_wrap(args) -# define array_adaptive_map_handle(args...) \ - CCC_array_adaptive_map_handle(args) -# define array_adaptive_map_and_modify(args...) \ - CCC_array_adaptive_map_and_modify(args) -# define array_adaptive_map_and_modify_context(args...) \ - CCC_array_adaptive_map_and_modify_context(args) -# define array_adaptive_map_or_insert(args...) \ - CCC_array_adaptive_map_or_insert(args) -# define array_adaptive_map_insert_handle(args...) \ - CCC_array_adaptive_map_insert_handle(args) -# define array_adaptive_map_unwrap(args...) \ - CCC_array_adaptive_map_unwrap(args) -# define array_adaptive_map_insert_error(args...) \ - CCC_array_adaptive_map_insert_error(args) -# define array_adaptive_map_occupied(args...) \ - CCC_array_adaptive_map_occupied(args) -# define array_adaptive_map_clear(args...) CCC_array_adaptive_map_clear(args) -# define array_adaptive_map_clear_and_free(args...) \ - CCC_array_adaptive_map_clear_and_free(args) -# define array_adaptive_map_clear_and_free_reserve(args...) \ - CCC_array_adaptive_map_clear_and_free_reserve(args) -# define array_adaptive_map_begin(args...) CCC_array_adaptive_map_begin(args) -# define array_adaptive_map_reverse_begin(args...) \ - CCC_array_adaptive_map_reverse_begin(args) -# define array_adaptive_map_end(args...) CCC_array_adaptive_map_end(args) -# define array_adaptive_map_reverse_end(args...) \ - CCC_array_adaptive_map_reverse_end(args) -# define array_adaptive_map_next(args...) CCC_array_adaptive_map_next(args) -# define array_adaptive_map_reverse_next(args...) \ - CCC_array_adaptive_map_reverse_next(args) -# define array_adaptive_map_count(args...) CCC_array_adaptive_map_count(args) -# define array_adaptive_map_capacity(args...) \ - CCC_array_adaptive_map_capacity(args) -# define array_adaptive_map_is_empty(args...) \ - CCC_array_adaptive_map_is_empty(args) -# define array_adaptive_map_validate(args...) \ - CCC_array_adaptive_map_validate(args) +# define array_adaptive_map_declare_fixed(arguments...) \ + CCC_array_adaptive_map_declare_fixed(arguments) +# define array_adaptive_map_fixed_capacity(arguments...) \ + CCC_array_adaptive_map_fixed_capacity(arguments) +# define array_adaptive_map_initialize(arguments...) \ + CCC_array_adaptive_map_initialize(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_compound_literal(arguments...) \ + CCC_array_adaptive_map_with_compound_literal(arguments) +# define array_adaptive_map_with_context_compound_literal(arguments...) \ + CCC_array_adaptive_map_with_context_compound_literal(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_array_with(arguments...) \ + CCC_array_adaptive_map_insert_array_with(arguments) +# define array_adaptive_map_try_insert_with(arguments...) \ + CCC_array_adaptive_map_try_insert_with(arguments) +# define array_adaptive_map_insert_or_assign_with(arguments...) \ + CCC_array_adaptive_map_insert_or_assign_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_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_and_modify_context(arguments...) \ + CCC_array_adaptive_map_and_modify_context(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_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_clear_and_free_reserve(arguments...) \ + CCC_array_adaptive_map_clear_and_free_reserve(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_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) #endif /* ARRAY_ADAPTIVE_MAP_USING_NAMESPACE_CCC */ #endif /* CCC_ARRAY_ADAPTIVE_MAP_H */ diff --git a/ccc/array_tree_map.h b/ccc/array_tree_map.h index 867fa41d..f852421b 100644 --- a/ccc/array_tree_map.h +++ b/ccc/array_tree_map.h @@ -1167,58 +1167,66 @@ CCC_array_tree_map_validate(CCC_Array_tree_map const *map); #ifdef ARRAY_TREE_MAP_USING_NAMESPACE_CCC typedef CCC_Array_tree_map Array_tree_map; typedef CCC_Array_tree_map_handle Array_tree_map_handle; -# define array_tree_map_declare_fixed(args...) \ - CCC_array_tree_map_declare_fixed(args) -# define array_tree_map_initialize(args...) \ - CCC_array_tree_map_initialize(args) -# define array_tree_map_from(args...) CCC_array_tree_map_from(args) -# define array_tree_map_with_capacity(args...) \ - CCC_array_tree_map_with_capacity(args) -# define array_tree_map_with_compound_literal(args...) \ - CCC_array_tree_map_with_compound_literal(args) -# define array_tree_map_with_context_compound_literal(args...) \ - CCC_array_tree_map_with_context_compound_literal(args) -# define array_tree_map_fixed_capacity(args...) \ - CCC_array_tree_map_fixed_capacity(args) -# define array_tree_map_copy(args...) CCC_array_tree_map_copy(args) -# define array_tree_map_reserve(args...) CCC_array_tree_map_reserve(args) -# define array_tree_map_at(args...) CCC_array_tree_map_at(args) -# define array_tree_map_as(args...) CCC_array_tree_map_as(args) -# define array_tree_map_and_modify_with(args...) \ - CCC_array_tree_map_and_modify_with(args) -# define array_tree_map_or_insert_with(args...) \ - CCC_array_tree_map_or_insert_with(args) -# define array_tree_map_insert_array_with(args...) \ - CCC_array_tree_map_insert_array_with(args) -# define array_tree_map_try_insert_with(args...) \ - CCC_array_tree_map_try_insert_with(args) -# define array_tree_map_insert_or_assign_with(args...) \ - CCC_array_tree_map_insert_or_assign_with(args) -# define array_tree_map_contains(args...) CCC_array_tree_map_contains(args) -# define array_tree_map_get_key_value(args...) \ - CCC_array_tree_map_get_key_value(args) -# define array_tree_map_swap_handle(args...) \ - CCC_array_tree_map_swap_handle(args) -# define array_tree_map_swap_handle_wrap(args...) \ - CCC_array_tree_map_swap_handle_wrap(args) -# define array_tree_map_begin(args...) CCC_array_tree_map_begin(args) -# define array_tree_map_reverse_begin(args...) \ - CCC_array_tree_map_reverse_begin(args) -# define array_tree_map_next(args...) CCC_array_tree_map_next(args) -# define array_tree_map_reverse_next(args...) \ - CCC_array_tree_map_reverse_next(args) -# define array_tree_map_end(args...) CCC_array_tree_map_end(args) -# define array_tree_map_reverse_end(args...) \ - CCC_array_tree_map_reverse_end(args) -# define array_tree_map_is_empty(args...) CCC_array_tree_map_is_empty(args) -# define array_tree_map_count(args...) CCC_array_tree_map_count(args) -# define array_tree_map_capacity(args...) CCC_array_tree_map_capacity(args) -# define array_tree_map_clear(args...) CCC_array_tree_map_clear(args) -# define array_tree_map_clear_and_free(args...) \ - CCC_array_tree_map_clear_and_free(args) -# define array_tree_map_clear_and_free_reserve(args...) \ - CCC_array_tree_map_clear_and_free_reserve(args) -# define array_tree_map_validate(args...) CCC_array_tree_map_validate(args) +# define array_tree_map_declare_fixed(arguments...) \ + CCC_array_tree_map_declare_fixed(arguments) +# define array_tree_map_initialize(arguments...) \ + CCC_array_tree_map_initialize(arguments) +# define array_tree_map_from(arguments...) CCC_array_tree_map_from(arguments) +# define array_tree_map_with_capacity(arguments...) \ + CCC_array_tree_map_with_capacity(arguments) +# define array_tree_map_with_compound_literal(arguments...) \ + CCC_array_tree_map_with_compound_literal(arguments) +# define array_tree_map_with_context_compound_literal(arguments...) \ + CCC_array_tree_map_with_context_compound_literal(arguments) +# define array_tree_map_fixed_capacity(arguments...) \ + CCC_array_tree_map_fixed_capacity(arguments) +# define array_tree_map_copy(arguments...) CCC_array_tree_map_copy(arguments) +# define array_tree_map_reserve(arguments...) \ + CCC_array_tree_map_reserve(arguments) +# define array_tree_map_at(arguments...) CCC_array_tree_map_at(arguments) +# define array_tree_map_as(arguments...) CCC_array_tree_map_as(arguments) +# define array_tree_map_and_modify_with(arguments...) \ + CCC_array_tree_map_and_modify_with(arguments) +# define array_tree_map_or_insert_with(arguments...) \ + CCC_array_tree_map_or_insert_with(arguments) +# define array_tree_map_insert_array_with(arguments...) \ + CCC_array_tree_map_insert_array_with(arguments) +# define array_tree_map_try_insert_with(arguments...) \ + CCC_array_tree_map_try_insert_with(arguments) +# define array_tree_map_insert_or_assign_with(arguments...) \ + CCC_array_tree_map_insert_or_assign_with(arguments) +# define array_tree_map_contains(arguments...) \ + CCC_array_tree_map_contains(arguments) +# define array_tree_map_get_key_value(arguments...) \ + CCC_array_tree_map_get_key_value(arguments) +# define array_tree_map_swap_handle(arguments...) \ + CCC_array_tree_map_swap_handle(arguments) +# define array_tree_map_swap_handle_wrap(arguments...) \ + CCC_array_tree_map_swap_handle_wrap(arguments) +# define array_tree_map_begin(arguments...) \ + CCC_array_tree_map_begin(arguments) +# define array_tree_map_reverse_begin(arguments...) \ + CCC_array_tree_map_reverse_begin(arguments) +# define array_tree_map_next(arguments...) CCC_array_tree_map_next(arguments) +# define array_tree_map_reverse_next(arguments...) \ + CCC_array_tree_map_reverse_next(arguments) +# define array_tree_map_end(arguments...) CCC_array_tree_map_end(arguments) +# define array_tree_map_reverse_end(arguments...) \ + CCC_array_tree_map_reverse_end(arguments) +# define array_tree_map_is_empty(arguments...) \ + CCC_array_tree_map_is_empty(arguments) +# define array_tree_map_count(arguments...) \ + CCC_array_tree_map_count(arguments) +# define array_tree_map_capacity(arguments...) \ + CCC_array_tree_map_capacity(arguments) +# define array_tree_map_clear(arguments...) \ + CCC_array_tree_map_clear(arguments) +# define array_tree_map_clear_and_free(arguments...) \ + CCC_array_tree_map_clear_and_free(arguments) +# define array_tree_map_clear_and_free_reserve(arguments...) \ + CCC_array_tree_map_clear_and_free_reserve(arguments) +# define array_tree_map_validate(arguments...) \ + CCC_array_tree_map_validate(arguments) #endif /* ARRAY_TREE_MAP_USING_NAMESPACE_CCC */ #endif /* CCC_ARRAY_TREE_MAP_H */ diff --git a/ccc/bitset.h b/ccc/bitset.h index f08738b4..e1952bd8 100644 --- a/ccc/bitset.h +++ b/ccc/bitset.h @@ -1035,87 +1035,93 @@ container. Check for namespace clashes before name shortening. */ #ifdef BITSET_USING_NAMESPACE_CCC typedef CCC_Bitset Bitset; # define BITSET_BLOCK_BITS CCC_BITSET_BLOCK_BITS -# define bitset_block_count(args...) CCC_bitset_block_count(args) -# define bitset_block_bytes(args...) CCC_bitset_block_bytes(args) -# define bitset_blocks(args...) CCC_bitset_blocks(args) -# define bitset_initialize(args...) CCC_bitset_initialize(args) -# define bitset_from(args...) CCC_bitset_from(args) -# define bitset_with_capacity(args...) CCC_bitset_with_capacity(args) -# define bitset_with_compound_literal(args...) \ - CCC_bitset_with_compound_literal(args) -# define bitset_with_context_compound_literal(args...) \ - CCC_bitset_with_context_compound_literal(args) -# define bitset_copy(args...) CCC_bitset_copy(args) -# define bitset_reserve(args...) CCC_bitset_reserve(args) -# define bitset_test(args...) CCC_bitset_test(args) -# define bitset_set(args...) CCC_bitset_set(args) -# define bitset_set_all(args...) CCC_bitset_set_all(args) -# define bitset_set_range(args...) CCC_bitset_set_range(args) -# define bitset_reset(args...) CCC_bitset_reset(args) -# define bitset_reset_all(args...) CCC_bitset_reset_all(args) -# define bitset_reset_range(args...) CCC_bitset_reset_range(args) -# define bitset_flip(args...) CCC_bitset_flip(args) -# define bitset_flip_all(args...) CCC_bitset_flip_all(args) -# define bitset_flip_range(args...) CCC_bitset_flip_range(args) -# define bitset_any(args...) CCC_bitset_any(args) -# define bitset_any_range(args...) CCC_bitset_any_range(args) -# define bitset_none(args...) CCC_bitset_none(args) -# define bitset_none_range(args...) CCC_bitset_none_range(args) -# define bitset_all(args...) CCC_bitset_all(args) -# define bitset_all_range(args...) CCC_bitset_all_range(args) -# define bitset_first_trailing_one(args...) \ - CCC_bitset_first_trailing_one(args) -# define bitset_first_trailing_one_range(args...) \ - CCC_bitset_first_trailing_one_range(args) -# define bitset_first_trailing_ones(args...) \ - CCC_bitset_first_trailing_ones(args) -# define bitset_first_trailing_ones_range(args...) \ - CCC_bitset_first_trailing_ones_range(args) -# define bitset_first_trailing_zero(args...) \ - CCC_bitset_first_trailing_zero(args) -# define bitset_first_trailing_zero_range(args...) \ - CCC_bitset_first_trailing_zero_range(args) -# define bitset_first_trailing_zeros(args...) \ - CCC_bitset_first_trailing_zeros(args) -# define bitset_first_trailing_zeros_range(args...) \ - CCC_bitset_first_trailing_zeros_range(args) -# define bitset_first_leading_one(args...) CCC_bitset_first_leading_one(args) -# define bitset_first_leading_one_range(args...) \ - CCC_bitset_first_leading_one_range(args) -# define bitset_first_leading_ones(args...) \ - CCC_bitset_first_leading_ones(args) -# define bitset_first_leading_ones_range(args...) \ - CCC_bitset_first_leading_ones_range(args) -# define bitset_first_leading_zero(args...) \ - CCC_bitset_first_leading_zero(args) -# define bitset_first_leading_zero_range(args...) \ - CCC_bitset_first_leading_zero_range(args) -# define bitset_first_leading_zeros(args...) \ - CCC_bitset_first_leading_zeros(args) -# define bitset_first_leading_zeros_range(args...) \ - CCC_bitset_first_leading_zeros_range(args) -# define bitset_or(args...) CCC_bitset_or(args) -# define bitset_and(args...) CCC_bitset_and(args) -# define bitset_xor(args...) CCC_bitset_xor(args) -# define bitset_shift_left(args...) CCC_bitset_shift_left(args) -# define bitset_shift_right(args...) CCC_bitset_shift_right(args) -# define bitset_is_equal(args...) CCC_bitset_is_equal(args) -# define bitset_is_proper_subset(args...) CCC_bitset_is_proper_subset(args) -# define bitset_is_subset(args...) CCC_bitset_is_subset(args) -# define bitset_data(args...) CCC_bitset_data(args) -# define bitset_capacity(args...) CCC_bitset_capacity(args) -# define bitset_blocks_capacity(args...) CCC_bitset_blocks_capacity(args) -# define bitset_count(args...) CCC_bitset_count(args) -# define bitset_blocks_count(args...) CCC_bitset_blocks_count(args) -# define bitset_is_empty(args...) CCC_bitset_is_empty(args) -# define bitset_popcount(args...) CCC_bitset_popcount(args) -# define bitset_popcount_range(args...) CCC_bitset_popcount_range(args) -# define bitset_clear(args...) CCC_bitset_clear(args) -# define bitset_clear_and_free(args...) CCC_bitset_clear_and_free(args) -# define bitset_clear_and_free_reserve(args...) \ - CCC_bitset_clear_and_free_reserve(args) -# define bitset_push_back(args...) CCC_bitset_push_back(args) -# define bitset_pop_back(args...) CCC_bitset_pop_back(args) +# define bitset_block_count(arguments...) CCC_bitset_block_count(arguments) +# define bitset_block_bytes(arguments...) CCC_bitset_block_bytes(arguments) +# define bitset_blocks(arguments...) CCC_bitset_blocks(arguments) +# define bitset_initialize(arguments...) CCC_bitset_initialize(arguments) +# define bitset_from(arguments...) CCC_bitset_from(arguments) +# define bitset_with_capacity(arguments...) \ + CCC_bitset_with_capacity(arguments) +# define bitset_with_compound_literal(arguments...) \ + CCC_bitset_with_compound_literal(arguments) +# define bitset_with_context_compound_literal(arguments...) \ + CCC_bitset_with_context_compound_literal(arguments) +# define bitset_copy(arguments...) CCC_bitset_copy(arguments) +# define bitset_reserve(arguments...) CCC_bitset_reserve(arguments) +# define bitset_test(arguments...) CCC_bitset_test(arguments) +# define bitset_set(arguments...) CCC_bitset_set(arguments) +# define bitset_set_all(arguments...) CCC_bitset_set_all(arguments) +# define bitset_set_range(arguments...) CCC_bitset_set_range(arguments) +# define bitset_reset(arguments...) CCC_bitset_reset(arguments) +# define bitset_reset_all(arguments...) CCC_bitset_reset_all(arguments) +# define bitset_reset_range(arguments...) CCC_bitset_reset_range(arguments) +# define bitset_flip(arguments...) CCC_bitset_flip(arguments) +# define bitset_flip_all(arguments...) CCC_bitset_flip_all(arguments) +# define bitset_flip_range(arguments...) CCC_bitset_flip_range(arguments) +# define bitset_any(arguments...) CCC_bitset_any(arguments) +# define bitset_any_range(arguments...) CCC_bitset_any_range(arguments) +# define bitset_none(arguments...) CCC_bitset_none(arguments) +# define bitset_none_range(arguments...) CCC_bitset_none_range(arguments) +# define bitset_all(arguments...) CCC_bitset_all(arguments) +# define bitset_all_range(arguments...) CCC_bitset_all_range(arguments) +# define bitset_first_trailing_one(arguments...) \ + CCC_bitset_first_trailing_one(arguments) +# define bitset_first_trailing_one_range(arguments...) \ + CCC_bitset_first_trailing_one_range(arguments) +# define bitset_first_trailing_ones(arguments...) \ + CCC_bitset_first_trailing_ones(arguments) +# define bitset_first_trailing_ones_range(arguments...) \ + CCC_bitset_first_trailing_ones_range(arguments) +# define bitset_first_trailing_zero(arguments...) \ + CCC_bitset_first_trailing_zero(arguments) +# define bitset_first_trailing_zero_range(arguments...) \ + CCC_bitset_first_trailing_zero_range(arguments) +# define bitset_first_trailing_zeros(arguments...) \ + CCC_bitset_first_trailing_zeros(arguments) +# define bitset_first_trailing_zeros_range(arguments...) \ + CCC_bitset_first_trailing_zeros_range(arguments) +# define bitset_first_leading_one(arguments...) \ + CCC_bitset_first_leading_one(arguments) +# define bitset_first_leading_one_range(arguments...) \ + CCC_bitset_first_leading_one_range(arguments) +# define bitset_first_leading_ones(arguments...) \ + CCC_bitset_first_leading_ones(arguments) +# define bitset_first_leading_ones_range(arguments...) \ + CCC_bitset_first_leading_ones_range(arguments) +# define bitset_first_leading_zero(arguments...) \ + CCC_bitset_first_leading_zero(arguments) +# define bitset_first_leading_zero_range(arguments...) \ + CCC_bitset_first_leading_zero_range(arguments) +# define bitset_first_leading_zeros(arguments...) \ + CCC_bitset_first_leading_zeros(arguments) +# define bitset_first_leading_zeros_range(arguments...) \ + CCC_bitset_first_leading_zeros_range(arguments) +# define bitset_or(arguments...) CCC_bitset_or(arguments) +# define bitset_and(arguments...) CCC_bitset_and(arguments) +# define bitset_xor(arguments...) CCC_bitset_xor(arguments) +# define bitset_shift_left(arguments...) CCC_bitset_shift_left(arguments) +# define bitset_shift_right(arguments...) CCC_bitset_shift_right(arguments) +# define bitset_is_equal(arguments...) CCC_bitset_is_equal(arguments) +# define bitset_is_proper_subset(arguments...) \ + CCC_bitset_is_proper_subset(arguments) +# define bitset_is_subset(arguments...) CCC_bitset_is_subset(arguments) +# define bitset_data(arguments...) CCC_bitset_data(arguments) +# define bitset_capacity(arguments...) CCC_bitset_capacity(arguments) +# define bitset_blocks_capacity(arguments...) \ + CCC_bitset_blocks_capacity(arguments) +# define bitset_count(arguments...) CCC_bitset_count(arguments) +# define bitset_blocks_count(arguments...) CCC_bitset_blocks_count(arguments) +# define bitset_is_empty(arguments...) CCC_bitset_is_empty(arguments) +# define bitset_popcount(arguments...) CCC_bitset_popcount(arguments) +# define bitset_popcount_range(arguments...) \ + CCC_bitset_popcount_range(arguments) +# define bitset_clear(arguments...) CCC_bitset_clear(arguments) +# define bitset_clear_and_free(arguments...) \ + CCC_bitset_clear_and_free(arguments) +# define bitset_clear_and_free_reserve(arguments...) \ + CCC_bitset_clear_and_free_reserve(arguments) +# define bitset_push_back(arguments...) CCC_bitset_push_back(arguments) +# define bitset_pop_back(arguments...) CCC_bitset_pop_back(arguments) #endif /* BITSET_USING_NAMESPACE_CCC */ #endif /* CCC_BITSET_H */ diff --git a/ccc/buffer.h b/ccc/buffer.h index 456ffb70..50ed2006 100644 --- a/ccc/buffer.h +++ b/ccc/buffer.h @@ -788,55 +788,60 @@ related types and methods. By default the prefix is required but may be dropped with this directive if one is sure no namespace collisions occur. */ #ifdef BUFFER_USING_NAMESPACE_CCC typedef CCC_Buffer Buffer; -# define buffer_initialize(args...) CCC_buffer_initialize(args) -# define buffer_with_compound_literal(args...) \ - CCC_buffer_with_compound_literal(args) -# define buffer_with_context_compound_literal(args...) \ - CCC_buffer_with_context_compound_literal(args) -# define buffer_with_capacity(args...) CCC_buffer_with_capacity(args) -# define buffer_from(args...) CCC_buffer_from(args) -# define buffer_allocate(args...) CCC_buffer_allocate(args) -# define buffer_reserve(args...) CCC_buffer_reserve(args) -# define buffer_copy(args...) CCC_buffer_copy(args) -# define buffer_clear(args...) CCC_buffer_clear(args) -# define buffer_clear_and_free(args...) CCC_buffer_clear_and_free(args) -# define buffer_clear_and_free_reserve(args...) \ - CCC_buffer_clear_and_free_reserve(args) -# define buffer_count(args...) CCC_buffer_count(args) -# define buffer_count_bytes(args...) CCC_buffer_count_bytes(args) -# define buffer_size_plus(args...) CCC_buffer_size_plus(args) -# define buffer_size_minus(args...) CCC_buffer_size_minus(args) -# define buffer_size_set(args...) CCC_buffer_size_set(args) -# define buffer_capacity(args...) CCC_buffer_capacity(args) -# define buffer_capacity_bytes(args...) CCC_buffer_capacity_bytes(args) -# define buffer_sizeof_type(args...) CCC_buffer_sizeof_type(args) -# define buffer_index(args...) CCC_buffer_index(args) -# define buffer_is_full(args...) CCC_buffer_is_full(args) -# define buffer_is_empty(args...) CCC_buffer_is_empty(args) -# define buffer_at(args...) CCC_buffer_at(args) -# define buffer_as(args...) CCC_buffer_as(args) -# define buffer_back(args...) CCC_buffer_back(args) -# define buffer_back_as(args...) CCC_buffer_back_as(args) -# define buffer_front(args...) CCC_buffer_front(args) -# define buffer_front_as(args...) CCC_buffer_front_as(args) -# define buffer_allocate_back(args...) CCC_buffer_allocate_back(args) -# define buffer_emplace(args...) CCC_buffer_emplace(args) -# define buffer_emplace_back(args...) CCC_buffer_emplace_back(args) -# define buffer_push_back(args...) CCC_buffer_push_back(args) -# define buffer_pop_back(args...) CCC_buffer_pop_back(args) -# define buffer_pop_back_n(args...) CCC_buffer_pop_back_n(args) -# define buffer_move(args...) CCC_buffer_move(args) -# define buffer_swap(args...) CCC_buffer_swap(args) -# define buffer_write(args...) CCC_buffer_write(args) -# define buffer_erase(args...) CCC_buffer_erase(args) -# define buffer_insert(args...) CCC_buffer_insert(args) -# define buffer_begin(args...) CCC_buffer_begin(args) -# define buffer_next(args...) CCC_buffer_next(args) -# define buffer_end(args...) CCC_buffer_end(args) -# define buffer_reverse_begin(args...) CCC_buffer_reverse_begin(args) -# define buffer_reverse_next(args...) CCC_buffer_reverse_next(args) -# define buffer_reverse_end(args...) CCC_buffer_reverse_end(args) -# define buffer_capacity_end(args...) CCC_buffer_capacity_end(args) +# define buffer_initialize(arguments...) CCC_buffer_initialize(arguments) +# define buffer_with_compound_literal(arguments...) \ + CCC_buffer_with_compound_literal(arguments) +# define buffer_with_context_compound_literal(arguments...) \ + CCC_buffer_with_context_compound_literal(arguments) +# define buffer_with_capacity(arguments...) \ + CCC_buffer_with_capacity(arguments) +# define buffer_from(arguments...) CCC_buffer_from(arguments) +# define buffer_allocate(arguments...) CCC_buffer_allocate(arguments) +# define buffer_reserve(arguments...) CCC_buffer_reserve(arguments) +# define buffer_copy(arguments...) CCC_buffer_copy(arguments) +# define buffer_clear(arguments...) CCC_buffer_clear(arguments) +# define buffer_clear_and_free(arguments...) \ + CCC_buffer_clear_and_free(arguments) +# define buffer_clear_and_free_reserve(arguments...) \ + CCC_buffer_clear_and_free_reserve(arguments) +# define buffer_count(arguments...) CCC_buffer_count(arguments) +# define buffer_count_bytes(arguments...) CCC_buffer_count_bytes(arguments) +# define buffer_size_plus(arguments...) CCC_buffer_size_plus(arguments) +# define buffer_size_minus(arguments...) CCC_buffer_size_minus(arguments) +# define buffer_size_set(arguments...) CCC_buffer_size_set(arguments) +# define buffer_capacity(arguments...) CCC_buffer_capacity(arguments) +# define buffer_capacity_bytes(arguments...) \ + CCC_buffer_capacity_bytes(arguments) +# define buffer_sizeof_type(arguments...) CCC_buffer_sizeof_type(arguments) +# define buffer_index(arguments...) CCC_buffer_index(arguments) +# define buffer_is_full(arguments...) CCC_buffer_is_full(arguments) +# define buffer_is_empty(arguments...) CCC_buffer_is_empty(arguments) +# define buffer_at(arguments...) CCC_buffer_at(arguments) +# define buffer_as(arguments...) CCC_buffer_as(arguments) +# define buffer_back(arguments...) CCC_buffer_back(arguments) +# define buffer_back_as(arguments...) CCC_buffer_back_as(arguments) +# define buffer_front(arguments...) CCC_buffer_front(arguments) +# define buffer_front_as(arguments...) CCC_buffer_front_as(arguments) +# define buffer_allocate_back(arguments...) \ + CCC_buffer_allocate_back(arguments) +# define buffer_emplace(arguments...) CCC_buffer_emplace(arguments) +# define buffer_emplace_back(arguments...) CCC_buffer_emplace_back(arguments) +# define buffer_push_back(arguments...) CCC_buffer_push_back(arguments) +# define buffer_pop_back(arguments...) CCC_buffer_pop_back(arguments) +# define buffer_pop_back_n(arguments...) CCC_buffer_pop_back_n(arguments) +# define buffer_move(arguments...) CCC_buffer_move(arguments) +# define buffer_swap(arguments...) CCC_buffer_swap(arguments) +# define buffer_write(arguments...) CCC_buffer_write(arguments) +# define buffer_erase(arguments...) CCC_buffer_erase(arguments) +# define buffer_insert(arguments...) CCC_buffer_insert(arguments) +# define buffer_begin(arguments...) CCC_buffer_begin(arguments) +# define buffer_next(arguments...) CCC_buffer_next(arguments) +# define buffer_end(arguments...) CCC_buffer_end(arguments) +# define buffer_reverse_begin(arguments...) \ + CCC_buffer_reverse_begin(arguments) +# define buffer_reverse_next(arguments...) CCC_buffer_reverse_next(arguments) +# define buffer_reverse_end(arguments...) CCC_buffer_reverse_end(arguments) +# define buffer_capacity_end(arguments...) CCC_buffer_capacity_end(arguments) #endif /* BUFFER_USING_NAMESPACE_CCC */ #endif /* CCC_BUFFER_H */ diff --git a/ccc/doubly_linked_list.h b/ccc/doubly_linked_list.h index be7629e6..ebf7ba32 100644 --- a/ccc/doubly_linked_list.h +++ b/ccc/doubly_linked_list.h @@ -461,56 +461,66 @@ clashes exist prior to name shortening. */ #ifdef DOUBLY_LINKED_LIST_USING_NAMESPACE_CCC typedef CCC_Doubly_linked_list_node Doubly_linked_list_node; typedef CCC_Doubly_linked_list Doubly_linked_list; -# define doubly_linked_list_initialize(args...) \ - CCC_doubly_linked_list_initialize(args) -# define doubly_linked_list_from(args...) CCC_doubly_linked_list_from(args) -# define doubly_linked_list_emplace_back(args...) \ - CCC_doubly_linked_list_emplace_back(args) -# define doubly_linked_list_emplace_front(args...) \ - CCC_doubly_linked_list_emplace_front(args) -# define doubly_linked_list_push_front(args...) \ - CCC_doubly_linked_list_push_front(args) -# define doubly_linked_list_push_back(args...) \ - CCC_doubly_linked_list_push_back(args) -# define doubly_linked_list_front(args...) CCC_doubly_linked_list_front(args) -# define doubly_linked_list_back(args...) CCC_doubly_linked_list_back(args) -# define doubly_linked_list_pop_front(args...) \ - CCC_doubly_linked_list_pop_front(args) -# define doubly_linked_list_pop_back(args...) \ - CCC_doubly_linked_list_pop_back(args) -# define doubly_linked_list_extract(args...) \ - CCC_doubly_linked_list_extract(args) -# define doubly_linked_list_extract_range(args...) \ - CCC_doubly_linked_list_extract_range(args) -# define doubly_linked_list_erase(args...) CCC_doubly_linked_list_erase(args) -# define doubly_linked_list_erase_range(args...) \ - CCC_doubly_linked_list_erase_range(args) -# define doubly_linked_list_splice(args...) \ - CCC_doubly_linked_list_splice(args) -# define doubly_linked_list_splice_range(args...) \ - CCC_doubly_linked_list_splice_range(args) -# define doubly_linked_list_sort(args...) CCC_doubly_linked_list_sort(args) -# define doubly_linked_list_insert_sorted(args...) \ - CCC_doubly_linked_list_insert_sorted(args) -# define doubly_linked_list_is_sorted(args...) \ - CCC_doubly_linked_list_is_sorted(args) -# define doubly_linked_list_begin(args...) CCC_doubly_linked_list_begin(args) -# define doubly_linked_list_next(args...) CCC_doubly_linked_list_next(args) -# define doubly_linked_list_reverse_begin(args...) \ - CCC_doubly_linked_list_reverse_begin(args) -# define doubly_linked_list_reverse_next(args...) \ - CCC_doubly_linked_list_reverse_next(args) -# define doubly_linked_list_end(args...) CCC_doubly_linked_list_end(args) -# define doubly_linked_list_reverse_end(args...) \ - CCC_doubly_linked_list_reverse_end(args) -# define doubly_linked_list_node_begin(args...) \ - CCC_doubly_linked_list_node_begin(args) -# define doubly_linked_list_count(args...) CCC_doubly_linked_list_count(args) -# define doubly_linked_list_is_empty(args...) \ - CCC_doubly_linked_list_is_empty(args) -# define doubly_linked_list_clear(args...) CCC_doubly_linked_list_clear(args) -# define doubly_linked_list_validate(args...) \ - CCC_doubly_linked_list_validate(args) +# define doubly_linked_list_initialize(arguments...) \ + CCC_doubly_linked_list_initialize(arguments) +# define doubly_linked_list_from(arguments...) \ + CCC_doubly_linked_list_from(arguments) +# define doubly_linked_list_emplace_back(arguments...) \ + CCC_doubly_linked_list_emplace_back(arguments) +# define doubly_linked_list_emplace_front(arguments...) \ + CCC_doubly_linked_list_emplace_front(arguments) +# define doubly_linked_list_push_front(arguments...) \ + CCC_doubly_linked_list_push_front(arguments) +# define doubly_linked_list_push_back(arguments...) \ + CCC_doubly_linked_list_push_back(arguments) +# define doubly_linked_list_front(arguments...) \ + CCC_doubly_linked_list_front(arguments) +# define doubly_linked_list_back(arguments...) \ + CCC_doubly_linked_list_back(arguments) +# define doubly_linked_list_pop_front(arguments...) \ + CCC_doubly_linked_list_pop_front(arguments) +# define doubly_linked_list_pop_back(arguments...) \ + CCC_doubly_linked_list_pop_back(arguments) +# define doubly_linked_list_extract(arguments...) \ + CCC_doubly_linked_list_extract(arguments) +# define doubly_linked_list_extract_range(arguments...) \ + CCC_doubly_linked_list_extract_range(arguments) +# define doubly_linked_list_erase(arguments...) \ + CCC_doubly_linked_list_erase(arguments) +# define doubly_linked_list_erase_range(arguments...) \ + CCC_doubly_linked_list_erase_range(arguments) +# define doubly_linked_list_splice(arguments...) \ + CCC_doubly_linked_list_splice(arguments) +# define doubly_linked_list_splice_range(arguments...) \ + CCC_doubly_linked_list_splice_range(arguments) +# define doubly_linked_list_sort(arguments...) \ + CCC_doubly_linked_list_sort(arguments) +# define doubly_linked_list_insert_sorted(arguments...) \ + CCC_doubly_linked_list_insert_sorted(arguments) +# define doubly_linked_list_is_sorted(arguments...) \ + CCC_doubly_linked_list_is_sorted(arguments) +# define doubly_linked_list_begin(arguments...) \ + CCC_doubly_linked_list_begin(arguments) +# define doubly_linked_list_next(arguments...) \ + CCC_doubly_linked_list_next(arguments) +# define doubly_linked_list_reverse_begin(arguments...) \ + CCC_doubly_linked_list_reverse_begin(arguments) +# define doubly_linked_list_reverse_next(arguments...) \ + CCC_doubly_linked_list_reverse_next(arguments) +# define doubly_linked_list_end(arguments...) \ + CCC_doubly_linked_list_end(arguments) +# define doubly_linked_list_reverse_end(arguments...) \ + CCC_doubly_linked_list_reverse_end(arguments) +# define doubly_linked_list_node_begin(arguments...) \ + CCC_doubly_linked_list_node_begin(arguments) +# define doubly_linked_list_count(arguments...) \ + CCC_doubly_linked_list_count(arguments) +# define doubly_linked_list_is_empty(arguments...) \ + CCC_doubly_linked_list_is_empty(arguments) +# define doubly_linked_list_clear(arguments...) \ + CCC_doubly_linked_list_clear(arguments) +# define doubly_linked_list_validate(arguments...) \ + CCC_doubly_linked_list_validate(arguments) #endif /* DOUBLY_LINKED_LIST_USING_NAMESPACE_CCC */ #endif /* CCC_LIST_H */ diff --git a/ccc/flat_double_ended_queue.h b/ccc/flat_double_ended_queue.h index edb50787..c04395c8 100644 --- a/ccc/flat_double_ended_queue.h +++ b/ccc/flat_double_ended_queue.h @@ -686,64 +686,64 @@ flat_double_ended_queue container. Ensure no namespace collisions occur before name shortening. */ #ifdef FLAT_DOUBLE_ENDED_QUEUE_USING_NAMESPACE_CCC typedef CCC_Flat_double_ended_queue Flat_double_ended_queue; -# define flat_double_ended_queue_initialize(args...) \ - CCC_flat_double_ended_queue_initialize(args) -# define flat_double_ended_queue_from(args...) \ - CCC_flat_double_ended_queue_from(args) -# define flat_double_ended_queue_with_capacity(args...) \ - CCC_flat_double_ended_queue_with_capacity(args) -# define flat_double_ended_queue_copy(args...) \ - CCC_flat_double_ended_queue_copy(args) -# define flat_double_ended_queue_reserve(args...) \ - CCC_flat_double_ended_queue_reserve(args) -# define flat_double_ended_queue_emplace(args...) \ - CCC_flat_double_ended_queue_emplace(args) -# define flat_double_ended_queue_push_back(args...) \ - CCC_flat_double_ended_queue_push_back(args) -# define flat_double_ended_queue_push_back_range(args...) \ - CCC_flat_double_ended_queue_push_back_range(args) -# define flat_double_ended_queue_push_front(args...) \ - CCC_flat_double_ended_queue_push_front(args) -# define flat_double_ended_queue_push_front_range(args...) \ - CCC_flat_double_ended_queue_push_front_range(args) -# define flat_double_ended_queue_insert_range(args...) \ - CCC_flat_double_ended_queue_insert_range(args) -# define flat_double_ended_queue_pop_front(args...) \ - CCC_flat_double_ended_queue_pop_front(args) -# define flat_double_ended_queue_pop_back(args...) \ - CCC_flat_double_ended_queue_pop_back(args) -# define flat_double_ended_queue_front(args...) \ - CCC_flat_double_ended_queue_front(args) -# define flat_double_ended_queue_back(args...) \ - CCC_flat_double_ended_queue_back(args) -# define flat_double_ended_queue_is_empty(args...) \ - CCC_flat_double_ended_queue_is_empty(args) -# define flat_double_ended_queue_count(args...) \ - CCC_flat_double_ended_queue_count(args) -# define flat_double_ended_queue_clear(args...) \ - CCC_flat_double_ended_queue_clear(args) -# define flat_double_ended_queue_clear_and_free(args...) \ - CCC_flat_double_ended_queue_clear_and_free(args) -# define flat_double_ended_queue_clear_and_free_reserve(args...) \ - CCC_flat_double_ended_queue_clear_and_free_reserve(args) -# define flat_double_ended_queue_at(args...) \ - CCC_flat_double_ended_queue_at(args) -# define flat_double_ended_queue_data(args...) \ - CCC_flat_double_ended_queue_data(args) -# define flat_double_ended_queue_begin(args...) \ - CCC_flat_double_ended_queue_begin(args) -# define flat_double_ended_queue_reverse_begin(args...) \ - CCC_flat_double_ended_queue_reverse_begin(args) -# define flat_double_ended_queue_next(args...) \ - CCC_flat_double_ended_queue_next(args) -# define flat_double_ended_queue_reverse_next(args...) \ - CCC_flat_double_ended_queue_reverse_next(args) -# define flat_double_ended_queue_end(args...) \ - CCC_flat_double_ended_queue_end(args) -# define flat_double_ended_queue_reverse_end(args...) \ - CCC_flat_double_ended_queue_reverse_end(args) -# define flat_double_ended_queue_validate(args...) \ - CCC_flat_double_ended_queue_validate(args) +# define flat_double_ended_queue_initialize(arguments...) \ + CCC_flat_double_ended_queue_initialize(arguments) +# define flat_double_ended_queue_from(arguments...) \ + CCC_flat_double_ended_queue_from(arguments) +# define flat_double_ended_queue_with_capacity(arguments...) \ + CCC_flat_double_ended_queue_with_capacity(arguments) +# define flat_double_ended_queue_copy(arguments...) \ + CCC_flat_double_ended_queue_copy(arguments) +# define flat_double_ended_queue_reserve(arguments...) \ + CCC_flat_double_ended_queue_reserve(arguments) +# define flat_double_ended_queue_emplace(arguments...) \ + CCC_flat_double_ended_queue_emplace(arguments) +# define flat_double_ended_queue_push_back(arguments...) \ + CCC_flat_double_ended_queue_push_back(arguments) +# define flat_double_ended_queue_push_back_range(arguments...) \ + CCC_flat_double_ended_queue_push_back_range(arguments) +# define flat_double_ended_queue_push_front(arguments...) \ + CCC_flat_double_ended_queue_push_front(arguments) +# define flat_double_ended_queue_push_front_range(arguments...) \ + CCC_flat_double_ended_queue_push_front_range(arguments) +# define flat_double_ended_queue_insert_range(arguments...) \ + CCC_flat_double_ended_queue_insert_range(arguments) +# define flat_double_ended_queue_pop_front(arguments...) \ + CCC_flat_double_ended_queue_pop_front(arguments) +# define flat_double_ended_queue_pop_back(arguments...) \ + CCC_flat_double_ended_queue_pop_back(arguments) +# define flat_double_ended_queue_front(arguments...) \ + CCC_flat_double_ended_queue_front(arguments) +# define flat_double_ended_queue_back(arguments...) \ + CCC_flat_double_ended_queue_back(arguments) +# define flat_double_ended_queue_is_empty(arguments...) \ + CCC_flat_double_ended_queue_is_empty(arguments) +# define flat_double_ended_queue_count(arguments...) \ + CCC_flat_double_ended_queue_count(arguments) +# define flat_double_ended_queue_clear(arguments...) \ + CCC_flat_double_ended_queue_clear(arguments) +# define flat_double_ended_queue_clear_and_free(arguments...) \ + CCC_flat_double_ended_queue_clear_and_free(arguments) +# define flat_double_ended_queue_clear_and_free_reserve(arguments...) \ + CCC_flat_double_ended_queue_clear_and_free_reserve(arguments) +# define flat_double_ended_queue_at(arguments...) \ + CCC_flat_double_ended_queue_at(arguments) +# define flat_double_ended_queue_data(arguments...) \ + CCC_flat_double_ended_queue_data(arguments) +# define flat_double_ended_queue_begin(arguments...) \ + CCC_flat_double_ended_queue_begin(arguments) +# define flat_double_ended_queue_reverse_begin(arguments...) \ + CCC_flat_double_ended_queue_reverse_begin(arguments) +# define flat_double_ended_queue_next(arguments...) \ + CCC_flat_double_ended_queue_next(arguments) +# define flat_double_ended_queue_reverse_next(arguments...) \ + CCC_flat_double_ended_queue_reverse_next(arguments) +# define flat_double_ended_queue_end(arguments...) \ + CCC_flat_double_ended_queue_end(arguments) +# define flat_double_ended_queue_reverse_end(arguments...) \ + CCC_flat_double_ended_queue_reverse_end(arguments) +# define flat_double_ended_queue_validate(arguments...) \ + CCC_flat_double_ended_queue_validate(arguments) #endif /* FLAT_DOUBLE_ENDED_QUEUE_USING_NAMESPACE_CCC */ #endif /* CCC_FLAT_DOUBLE_ENDED_QUEUE_H */ diff --git a/ccc/flat_hash_map.h b/ccc/flat_hash_map.h index 5fb72047..62b0446a 100644 --- a/ccc/flat_hash_map.h +++ b/ccc/flat_hash_map.h @@ -1154,75 +1154,88 @@ CCC_flat_hash_map_validate(CCC_Flat_hash_map const *map); #ifdef FLAT_HASH_MAP_USING_NAMESPACE_CCC typedef CCC_Flat_hash_map Flat_hash_map; typedef CCC_Flat_hash_map_entry Flat_hash_map_entry; -# define flat_hash_map_declare_fixed(args...) \ - CCC_flat_hash_map_declare_fixed(args) -# define flat_hash_map_fixed_capacity(args...) \ - CCC_flat_hash_map_fixed_capacity(args) -# define flat_hash_map_reserve(args...) CCC_flat_hash_map_reserve(args) -# define flat_hash_map_initialize(args...) CCC_flat_hash_map_initialize(args) -# define flat_hash_map_from(args...) CCC_flat_hash_map_from(args) -# define flat_hash_map_with_capacity(args...) \ - CCC_flat_hash_map_with_capacity(args) -# define flat_hash_map_with_compound_literal(args...) \ - CCC_flat_hash_map_with_compound_literal(args) -# define flat_hash_map_with_context_compound_literal(args...) \ - CCC_flat_hash_map_with_context_compound_literal(args) -# define flat_hash_map_copy(args...) CCC_flat_hash_map_copy(args) -# define flat_hash_map_and_modify_with(args...) \ - CCC_flat_hash_map_and_modify_with(args) -# define flat_hash_map_or_insert_with(args...) \ - CCC_flat_hash_map_or_insert_with(args) -# define flat_hash_map_insert_entry_with(args...) \ - CCC_flat_hash_map_insert_entry_with(args) -# define flat_hash_map_try_insert_with(args...) \ - CCC_flat_hash_map_try_insert_with(args) -# define flat_hash_map_insert_or_assign_with(args...) \ - CCC_flat_hash_map_insert_or_assign_with(args) -# define flat_hash_map_contains(args...) CCC_flat_hash_map_contains(args) -# define flat_hash_map_get_key_value(args...) \ - CCC_flat_hash_map_get_key_value(args) -# define flat_hash_map_remove_key_value_wrap(args...) \ - CCC_flat_hash_map_remove_key_value_wrap(args) -# define flat_hash_map_swap_entry_wrap(args...) \ - CCC_flat_hash_map_swap_entry_wrap(args) -# define flat_hash_map_try_insert_wrap(args...) \ - CCC_flat_hash_map_try_insert_wrap(args) -# define flat_hash_map_insert_or_assign_wrap(args...) \ - CCC_flat_hash_map_insert_or_assign_wrap(args) -# define flat_hash_map_remove_entry_wrap(args...) \ - CCC_flat_hash_map_remove_entry_wrap(args) -# define flat_hash_map_remove_key_value(args...) \ - CCC_flat_hash_map_remove_key_value(args) -# define flat_hash_map_swap_entry(args...) CCC_flat_hash_map_swap_entry(args) -# define flat_hash_map_try_insert(args...) CCC_flat_hash_map_try_insert(args) -# define flat_hash_map_insert_or_assign(args...) \ - CCC_flat_hash_map_insert_or_assign(args) -# define flat_hash_map_remove_entry(args...) \ - CCC_flat_hash_map_remove_entry(args) -# define flat_hash_map_entry_wrap(args...) CCC_flat_hash_map_entry_wrap(args) -# define flat_hash_map_entry(args...) CCC_flat_hash_map_entry(args) -# define flat_hash_map_and_modify(args...) CCC_flat_hash_map_and_modify(args) -# define flat_hash_map_and_modify_context(args...) \ - CCC_flat_hash_map_and_modify_context(args) -# define flat_hash_map_or_insert(args...) CCC_flat_hash_map_or_insert(args) -# define flat_hash_map_insert_entry(args...) \ - CCC_flat_hash_map_insert_entry(args) -# define flat_hash_map_unwrap(args...) CCC_flat_hash_map_unwrap(args) -# define flat_hash_map_occupied(args...) CCC_flat_hash_map_occupied(args) -# define flat_hash_map_insert_error(args...) \ - CCC_flat_hash_map_insert_error(args) -# define flat_hash_map_begin(args...) CCC_flat_hash_map_begin(args) -# define flat_hash_map_next(args...) CCC_flat_hash_map_next(args) -# define flat_hash_map_end(args...) CCC_flat_hash_map_end(args) -# define flat_hash_map_is_empty(args...) CCC_flat_hash_map_is_empty(args) -# define flat_hash_map_count(args...) CCC_flat_hash_map_count(args) -# define flat_hash_map_clear(args...) CCC_flat_hash_map_clear(args) -# define flat_hash_map_clear_and_free(args...) \ - CCC_flat_hash_map_clear_and_free(args) -# define flat_hash_map_clear_and_free_reserve(args...) \ - CCC_flat_hash_map_clear_and_free_reserve(args) -# define flat_hash_map_capacity(args...) CCC_flat_hash_map_capacity(args) -# define flat_hash_map_validate(args...) CCC_flat_hash_map_validate(args) +# define flat_hash_map_declare_fixed(arguments...) \ + CCC_flat_hash_map_declare_fixed(arguments) +# define flat_hash_map_fixed_capacity(arguments...) \ + CCC_flat_hash_map_fixed_capacity(arguments) +# define flat_hash_map_reserve(arguments...) \ + CCC_flat_hash_map_reserve(arguments) +# define flat_hash_map_initialize(arguments...) \ + CCC_flat_hash_map_initialize(arguments) +# define flat_hash_map_from(arguments...) CCC_flat_hash_map_from(arguments) +# define flat_hash_map_with_capacity(arguments...) \ + CCC_flat_hash_map_with_capacity(arguments) +# define flat_hash_map_with_compound_literal(arguments...) \ + CCC_flat_hash_map_with_compound_literal(arguments) +# define flat_hash_map_with_context_compound_literal(arguments...) \ + CCC_flat_hash_map_with_context_compound_literal(arguments) +# define flat_hash_map_copy(arguments...) CCC_flat_hash_map_copy(arguments) +# define flat_hash_map_and_modify_with(arguments...) \ + CCC_flat_hash_map_and_modify_with(arguments) +# define flat_hash_map_or_insert_with(arguments...) \ + CCC_flat_hash_map_or_insert_with(arguments) +# define flat_hash_map_insert_entry_with(arguments...) \ + CCC_flat_hash_map_insert_entry_with(arguments) +# define flat_hash_map_try_insert_with(arguments...) \ + CCC_flat_hash_map_try_insert_with(arguments) +# define flat_hash_map_insert_or_assign_with(arguments...) \ + CCC_flat_hash_map_insert_or_assign_with(arguments) +# define flat_hash_map_contains(arguments...) \ + CCC_flat_hash_map_contains(arguments) +# define flat_hash_map_get_key_value(arguments...) \ + CCC_flat_hash_map_get_key_value(arguments) +# define flat_hash_map_remove_key_value_wrap(arguments...) \ + CCC_flat_hash_map_remove_key_value_wrap(arguments) +# define flat_hash_map_swap_entry_wrap(arguments...) \ + CCC_flat_hash_map_swap_entry_wrap(arguments) +# define flat_hash_map_try_insert_wrap(arguments...) \ + CCC_flat_hash_map_try_insert_wrap(arguments) +# define flat_hash_map_insert_or_assign_wrap(arguments...) \ + CCC_flat_hash_map_insert_or_assign_wrap(arguments) +# define flat_hash_map_remove_entry_wrap(arguments...) \ + CCC_flat_hash_map_remove_entry_wrap(arguments) +# define flat_hash_map_remove_key_value(arguments...) \ + CCC_flat_hash_map_remove_key_value(arguments) +# define flat_hash_map_swap_entry(arguments...) \ + CCC_flat_hash_map_swap_entry(arguments) +# define flat_hash_map_try_insert(arguments...) \ + CCC_flat_hash_map_try_insert(arguments) +# define flat_hash_map_insert_or_assign(arguments...) \ + CCC_flat_hash_map_insert_or_assign(arguments) +# define flat_hash_map_remove_entry(arguments...) \ + CCC_flat_hash_map_remove_entry(arguments) +# define flat_hash_map_entry_wrap(arguments...) \ + CCC_flat_hash_map_entry_wrap(arguments) +# define flat_hash_map_entry(arguments...) CCC_flat_hash_map_entry(arguments) +# define flat_hash_map_and_modify(arguments...) \ + CCC_flat_hash_map_and_modify(arguments) +# define flat_hash_map_and_modify_context(arguments...) \ + CCC_flat_hash_map_and_modify_context(arguments) +# define flat_hash_map_or_insert(arguments...) \ + CCC_flat_hash_map_or_insert(arguments) +# define flat_hash_map_insert_entry(arguments...) \ + CCC_flat_hash_map_insert_entry(arguments) +# define flat_hash_map_unwrap(arguments...) \ + CCC_flat_hash_map_unwrap(arguments) +# define flat_hash_map_occupied(arguments...) \ + CCC_flat_hash_map_occupied(arguments) +# define flat_hash_map_insert_error(arguments...) \ + CCC_flat_hash_map_insert_error(arguments) +# define flat_hash_map_begin(arguments...) CCC_flat_hash_map_begin(arguments) +# define flat_hash_map_next(arguments...) CCC_flat_hash_map_next(arguments) +# define flat_hash_map_end(arguments...) CCC_flat_hash_map_end(arguments) +# define flat_hash_map_is_empty(arguments...) \ + CCC_flat_hash_map_is_empty(arguments) +# define flat_hash_map_count(arguments...) CCC_flat_hash_map_count(arguments) +# define flat_hash_map_clear(arguments...) CCC_flat_hash_map_clear(arguments) +# define flat_hash_map_clear_and_free(arguments...) \ + CCC_flat_hash_map_clear_and_free(arguments) +# define flat_hash_map_clear_and_free_reserve(arguments...) \ + CCC_flat_hash_map_clear_and_free_reserve(arguments) +# define flat_hash_map_capacity(arguments...) \ + CCC_flat_hash_map_capacity(arguments) +# define flat_hash_map_validate(arguments...) \ + CCC_flat_hash_map_validate(arguments) #endif #endif /* CCC_FLAT_HASH_MAP_H */ diff --git a/ccc/flat_priority_queue.h b/ccc/flat_priority_queue.h index 58e1507d..2a147731 100644 --- a/ccc/flat_priority_queue.h +++ b/ccc/flat_priority_queue.h @@ -455,8 +455,8 @@ CCC_flat_priority_queue_heapify_inplace(CCC_Flat_priority_queue *priority_queue, @param[in] type a pointer to the user element of same type as in flat_priority_queue. @param[in] temp a pointer to a dummy user type that will be used for swapping. -@return a pointer to the inserted element or NULl if NULL args are provided or -push required more memory and failed. Failure can occur if the +@return a pointer to the inserted element or NULl if NULL arguments are provided +or push required more memory and failed. Failure can occur if the flat_priority_queue is full and allocation is not allowed or a resize failed when allocation is allowed. @@ -484,7 +484,7 @@ element. @param[in] type a pointer to the stored priority_queue element. Must be in the flat_priority_queue. @param[in] temp a pointer to a dummy user type that will be used for swapping. -@return OK if the erase is successful or an input error if NULL args are +@return OK if the erase is successful or an input error if NULL arguments are provided or the priority_queue is empty. @warning the user must ensure e is in the flat_priority_queue. @@ -803,63 +803,68 @@ CCC_flat_priority_queue_order(CCC_Flat_priority_queue const *priority_queue); flat priority queue container. Check for collisions before name shortening. */ #ifdef FLAT_PRIORITY_QUEUE_USING_NAMESPACE_CCC typedef CCC_Flat_priority_queue Flat_priority_queue; -# define flat_priority_queue_initialize(args...) \ - CCC_flat_priority_queue_initialize(args) -# define flat_priority_queue_from(args...) CCC_flat_priority_queue_from(args) -# define flat_priority_queue_with_capacity(args...) \ - CCC_flat_priority_queue_with_capacity(args) -# define flat_priority_queue_with_compound_literal(args...) \ - CCC_flat_priority_queue_with_compound_literal(args) -# define flat_priority_queue_with_context_compound_literal(args...) \ - CCC_flat_priority_queue_with_context_compound_literal(args) -# define flat_priority_queue_heapify_initialize(args...) \ - CCC_flat_priority_queue_heapify_initialize(args) -# define flat_priority_queue_copy(args...) CCC_flat_priority_queue_copy(args) -# define flat_priority_queue_reserve(args...) \ - CCC_flat_priority_queue_reserve(args) -# define flat_priority_queue_heapify(args...) \ - CCC_flat_priority_queue_heapify(args) -# define flat_priority_queue_heapify_inplace(args...) \ - CCC_flat_priority_queue_heapify_inplace(args) -# define flat_priority_queue_heapsort(args...) \ - CCC_flat_priority_queue_heapsort(args) -# define flat_priority_queue_emplace(args...) \ - CCC_flat_priority_queue_emplace(args) -# define flat_priority_queue_push(args...) CCC_flat_priority_queue_push(args) -# define flat_priority_queue_front(args...) \ - CCC_flat_priority_queue_front(args) -# define flat_priority_queue_pop(args...) CCC_flat_priority_queue_pop(args) -# define flat_priority_queue_extract(args...) \ - CCC_flat_priority_queue_extract(args) -# define flat_priority_queue_update(args...) \ - CCC_flat_priority_queue_update(args) -# define flat_priority_queue_increase(args...) \ - CCC_flat_priority_queue_increase(args) -# define flat_priority_queue_decrease(args...) \ - CCC_flat_priority_queue_decrease(args) -# define flat_priority_queue_update_with(args...) \ - CCC_flat_priority_queue_update_with(args) -# define flat_priority_queue_increase_with(args...) \ - CCC_flat_priority_queue_increase_with(args) -# define flat_priority_queue_decrease_with(args...) \ - CCC_flat_priority_queue_decrease_with(args) -# define flat_priority_queue_clear(args...) \ - CCC_flat_priority_queue_clear(args) -# define flat_priority_queue_clear_and_free(args...) \ - CCC_flat_priority_queue_clear_and_free(args) -# define flat_priority_queue_clear_and_free_reserve(args...) \ - CCC_flat_priority_queue_clear_and_free_reserve(args) -# define flat_priority_queue_is_empty(args...) \ - CCC_flat_priority_queue_is_empty(args) -# define flat_priority_queue_count(args...) \ - CCC_flat_priority_queue_count(args) -# define flat_priority_queue_capacity(args...) \ - CCC_flat_priority_queue_capacity(args) -# define flat_priority_queue_data(args...) CCC_flat_priority_queue_data(args) -# define flat_priority_queue_validate(args...) \ - CCC_flat_priority_queue_validate(args) -# define flat_priority_queue_order(args...) \ - CCC_flat_priority_queue_order(args) +# define flat_priority_queue_initialize(arguments...) \ + CCC_flat_priority_queue_initialize(arguments) +# define flat_priority_queue_from(arguments...) \ + CCC_flat_priority_queue_from(arguments) +# define flat_priority_queue_with_capacity(arguments...) \ + CCC_flat_priority_queue_with_capacity(arguments) +# define flat_priority_queue_with_compound_literal(arguments...) \ + CCC_flat_priority_queue_with_compound_literal(arguments) +# define flat_priority_queue_with_context_compound_literal(arguments...) \ + CCC_flat_priority_queue_with_context_compound_literal(arguments) +# define flat_priority_queue_heapify_initialize(arguments...) \ + CCC_flat_priority_queue_heapify_initialize(arguments) +# define flat_priority_queue_copy(arguments...) \ + CCC_flat_priority_queue_copy(arguments) +# define flat_priority_queue_reserve(arguments...) \ + CCC_flat_priority_queue_reserve(arguments) +# define flat_priority_queue_heapify(arguments...) \ + CCC_flat_priority_queue_heapify(arguments) +# define flat_priority_queue_heapify_inplace(arguments...) \ + CCC_flat_priority_queue_heapify_inplace(arguments) +# define flat_priority_queue_heapsort(arguments...) \ + CCC_flat_priority_queue_heapsort(arguments) +# define flat_priority_queue_emplace(arguments...) \ + CCC_flat_priority_queue_emplace(arguments) +# define flat_priority_queue_push(arguments...) \ + CCC_flat_priority_queue_push(arguments) +# define flat_priority_queue_front(arguments...) \ + CCC_flat_priority_queue_front(arguments) +# define flat_priority_queue_pop(arguments...) \ + CCC_flat_priority_queue_pop(arguments) +# define flat_priority_queue_extract(arguments...) \ + CCC_flat_priority_queue_extract(arguments) +# define flat_priority_queue_update(arguments...) \ + CCC_flat_priority_queue_update(arguments) +# define flat_priority_queue_increase(arguments...) \ + CCC_flat_priority_queue_increase(arguments) +# define flat_priority_queue_decrease(arguments...) \ + CCC_flat_priority_queue_decrease(arguments) +# define flat_priority_queue_update_with(arguments...) \ + CCC_flat_priority_queue_update_with(arguments) +# define flat_priority_queue_increase_with(arguments...) \ + CCC_flat_priority_queue_increase_with(arguments) +# define flat_priority_queue_decrease_with(arguments...) \ + CCC_flat_priority_queue_decrease_with(arguments) +# define flat_priority_queue_clear(arguments...) \ + CCC_flat_priority_queue_clear(arguments) +# define flat_priority_queue_clear_and_free(arguments...) \ + CCC_flat_priority_queue_clear_and_free(arguments) +# define flat_priority_queue_clear_and_free_reserve(arguments...) \ + CCC_flat_priority_queue_clear_and_free_reserve(arguments) +# define flat_priority_queue_is_empty(arguments...) \ + CCC_flat_priority_queue_is_empty(arguments) +# define flat_priority_queue_count(arguments...) \ + CCC_flat_priority_queue_count(arguments) +# define flat_priority_queue_capacity(arguments...) \ + CCC_flat_priority_queue_capacity(arguments) +# define flat_priority_queue_data(arguments...) \ + CCC_flat_priority_queue_data(arguments) +# define flat_priority_queue_validate(arguments...) \ + CCC_flat_priority_queue_validate(arguments) +# define flat_priority_queue_order(arguments...) \ + CCC_flat_priority_queue_order(arguments) #endif /* FLAT_PRIORITY_QUEUE_USING_NAMESPACE_CCC */ #endif /* CCC_FLAT_PRIORITY_QUEUE_H */ diff --git a/ccc/priority_queue.h b/ccc/priority_queue.h index 88cd11a4..0e57eb82 100644 --- a/ccc/priority_queue.h +++ b/ccc/priority_queue.h @@ -355,7 +355,7 @@ Deallocate the container. */ /** @brief Removes all elements from the priority_queue, freeing if needed. @param[in] priority_queue a pointer to the priority queue. @param[in] destroy the destructor function or NULL if not needed. -@return ok if the clear was successful or an input error for NULL args. +@return ok if the clear was successful or an input error for NULL arguments. Note that if allocation is allowed the container will free the user type wrapping each element in the priority_queue. Therefore, the user should not free @@ -414,28 +414,39 @@ priority queue container. Check for collisions before name shortening. */ #ifdef PRIORITY_QUEUE_USING_NAMESPACE_CCC typedef CCC_Priority_queue_node priority_queue_node; typedef CCC_Priority_queue Priority_queue; -# define priority_queue_initialize(args...) \ - CCC_priority_queue_initialize(args) -# define priority_queue_from(args...) CCC_priority_queue_from(args) -# define priority_queue_front(args...) CCC_priority_queue_front(args) -# define priority_queue_push(args...) CCC_priority_queue_push(args) -# define priority_queue_emplace(args...) CCC_priority_queue_emplace(args) -# define priority_queue_pop(args...) CCC_priority_queue_pop(args) -# define priority_queue_extract(args...) CCC_priority_queue_extract(args) -# define priority_queue_is_empty(args...) CCC_priority_queue_is_empty(args) -# define priority_queue_count(args...) CCC_priority_queue_count(args) -# define priority_queue_update(args...) CCC_priority_queue_update(args) -# define priority_queue_increase(args...) CCC_priority_queue_increase(args) -# define priority_queue_decrease(args...) CCC_priority_queue_decrease(args) -# define priority_queue_update_with(args...) \ - CCC_priority_queue_update_with(args) -# define priority_queue_increase_with(args...) \ - CCC_priority_queue_increase_with(args) -# define priority_queue_decrease_with(args...) \ - CCC_priority_queue_decrease_with(args) -# define priority_queue_order(args...) CCC_priority_queue_order(args) -# define priority_queue_clear(args...) CCC_priority_queue_clear(args) -# define priority_queue_validate(args...) CCC_priority_queue_validate(args) +# define priority_queue_initialize(arguments...) \ + CCC_priority_queue_initialize(arguments) +# define priority_queue_from(arguments...) CCC_priority_queue_from(arguments) +# define priority_queue_front(arguments...) \ + CCC_priority_queue_front(arguments) +# define priority_queue_push(arguments...) CCC_priority_queue_push(arguments) +# define priority_queue_emplace(arguments...) \ + CCC_priority_queue_emplace(arguments) +# define priority_queue_pop(arguments...) CCC_priority_queue_pop(arguments) +# define priority_queue_extract(arguments...) \ + CCC_priority_queue_extract(arguments) +# define priority_queue_is_empty(arguments...) \ + CCC_priority_queue_is_empty(arguments) +# define priority_queue_count(arguments...) \ + CCC_priority_queue_count(arguments) +# define priority_queue_update(arguments...) \ + CCC_priority_queue_update(arguments) +# define priority_queue_increase(arguments...) \ + CCC_priority_queue_increase(arguments) +# define priority_queue_decrease(arguments...) \ + CCC_priority_queue_decrease(arguments) +# define priority_queue_update_with(arguments...) \ + CCC_priority_queue_update_with(arguments) +# define priority_queue_increase_with(arguments...) \ + CCC_priority_queue_increase_with(arguments) +# define priority_queue_decrease_with(arguments...) \ + CCC_priority_queue_decrease_with(arguments) +# define priority_queue_order(arguments...) \ + CCC_priority_queue_order(arguments) +# define priority_queue_clear(arguments...) \ + CCC_priority_queue_clear(arguments) +# define priority_queue_validate(arguments...) \ + CCC_priority_queue_validate(arguments) #endif /* PRIORITY_QUEUE_USING_NAMESPACE_CCC */ #endif /* CCC_PRIORITY_QUEUE_H */ diff --git a/ccc/private/private_traits.h b/ccc/private/private_traits.h index 339469ed..0cb78a16 100644 --- a/ccc/private/private_traits.h +++ b/ccc/private/private_traits.h @@ -34,12 +34,12 @@ limitations under the License. /*==================== Entry/Handle Interface =========================*/ -#define CCC_private_swap_entry(container_pointer, swap_args...) \ +#define CCC_private_swap_entry(container_pointer, swap_arguments...) \ _Generic((container_pointer), \ CCC_Flat_hash_map *: CCC_flat_hash_map_swap_entry, \ CCC_Adaptive_map *: CCC_adaptive_map_swap_entry, \ CCC_Tree_map *: CCC_tree_map_swap_entry)((container_pointer), \ - swap_args) + swap_arguments) #define CCC_private_swap_entry_wrap(container_pointer, \ key_val_container_array_pointer...) \ @@ -50,11 +50,11 @@ limitations under the License. .private \ } -#define CCC_private_swap_handle(container_pointer, swap_args...) \ +#define CCC_private_swap_handle(container_pointer, swap_arguments...) \ _Generic((container_pointer), \ CCC_Array_adaptive_map *: CCC_array_adaptive_map_swap_handle, \ CCC_Array_tree_map *: CCC_array_tree_map_swap_handle)( \ - (container_pointer), swap_args) + (container_pointer), swap_arguments) #define CCC_private_swap_handle_wrap(container_pointer, \ key_val_container_array_pointer...) \ @@ -65,80 +65,81 @@ limitations under the License. .private \ } -#define CCC_private_try_insert(container_pointer, try_insert_args...) \ +#define CCC_private_try_insert(container_pointer, try_insert_arguments...) \ _Generic((container_pointer), \ CCC_Array_adaptive_map *: CCC_array_adaptive_map_try_insert, \ CCC_Array_tree_map *: CCC_array_tree_map_try_insert, \ CCC_Flat_hash_map *: CCC_flat_hash_map_try_insert, \ CCC_Adaptive_map *: CCC_adaptive_map_try_insert, \ CCC_Tree_map *: CCC_tree_map_try_insert)((container_pointer), \ - try_insert_args) + try_insert_arguments) -#define CCC_private_try_insert_wrap(container_pointer, try_insert_args...) \ +#define CCC_private_try_insert_wrap(container_pointer, \ + try_insert_arguments...) \ _Generic((container_pointer), \ CCC_Array_adaptive_map *: &( \ CCC_Handle){CCC_array_adaptive_map_try_insert( \ (CCC_Array_adaptive_map *)container_pointer, \ - try_insert_args) \ + try_insert_arguments) \ .private}, \ CCC_Array_tree_map *: &( \ CCC_Handle){CCC_array_tree_map_try_insert( \ (CCC_Array_tree_map *)container_pointer, \ - try_insert_args) \ + try_insert_arguments) \ .private}, \ CCC_Flat_hash_map *: &( \ CCC_Entry){CCC_flat_hash_map_try_insert( \ (CCC_Flat_hash_map *)container_pointer, \ - try_insert_args) \ + try_insert_arguments) \ .private}, \ CCC_Adaptive_map *: &( \ CCC_Entry){CCC_adaptive_map_try_insert( \ (CCC_Adaptive_map *)container_pointer, \ - (CCC_Adaptive_map_node *)try_insert_args) \ + (CCC_Adaptive_map_node *)try_insert_arguments) \ .private}, \ CCC_Tree_map *: &(CCC_Entry){ \ CCC_tree_map_try_insert((CCC_Tree_map *)container_pointer, \ - (CCC_Tree_map_node *)try_insert_args) \ + (CCC_Tree_map_node *)try_insert_arguments) \ .private}) #define CCC_private_insert_or_assign(container_pointer, \ - insert_or_assign_args...) \ + insert_or_assign_arguments...) \ _Generic((container_pointer), \ CCC_Array_adaptive_map *: CCC_array_adaptive_map_insert_or_assign, \ CCC_Array_tree_map *: CCC_array_tree_map_insert_or_assign, \ CCC_Flat_hash_map *: CCC_flat_hash_map_insert_or_assign, \ CCC_Adaptive_map *: CCC_adaptive_map_insert_or_assign, \ - CCC_Tree_map *: CCC_tree_map_insert_or_assign)((container_pointer), \ - insert_or_assign_args) + CCC_Tree_map *: CCC_tree_map_insert_or_assign)( \ + (container_pointer), insert_or_assign_arguments) #define CCC_private_insert_or_assign_wrap(container_pointer, \ - insert_or_assign_args...) \ + insert_or_assign_arguments...) \ _Generic((container_pointer), \ CCC_Array_adaptive_map *: &( \ CCC_Handle){CCC_array_adaptive_map_insert_or_assign( \ (CCC_Array_adaptive_map *)container_pointer, \ - insert_or_assign_args) \ + insert_or_assign_arguments) \ .private}, \ CCC_Array_tree_map *: &( \ CCC_Handle){CCC_array_tree_map_insert_or_assign( \ (CCC_Array_tree_map *)container_pointer, \ - insert_or_assign_args) \ + insert_or_assign_arguments) \ .private}, \ CCC_Flat_hash_map *: &( \ CCC_Entry){CCC_flat_hash_map_insert_or_assign( \ (CCC_Flat_hash_map *)container_pointer, \ - insert_or_assign_args) \ + insert_or_assign_arguments) \ .private}, \ CCC_Adaptive_map *: &( \ CCC_Entry){CCC_adaptive_map_insert_or_assign( \ (CCC_Adaptive_map *)container_pointer, \ (CCC_Adaptive_map_node *) \ - insert_or_assign_args) \ + insert_or_assign_arguments) \ .private}, \ CCC_Tree_map *: &(CCC_Entry){ \ CCC_tree_map_insert_or_assign( \ (CCC_Tree_map *)container_pointer, \ - (CCC_Tree_map_node *)insert_or_assign_args) \ + (CCC_Tree_map_node *)insert_or_assign_arguments) \ .private}) #define CCC_private_remove_key_value(container_pointer, \ @@ -499,23 +500,23 @@ limitations under the License. /*================ Priority Queue Update Interface =====================*/ -#define CCC_private_update(container_pointer, update_args...) \ +#define CCC_private_update(container_pointer, update_arguments...) \ _Generic((container_pointer), \ CCC_Flat_priority_queue *: CCC_flat_priority_queue_update, \ CCC_Priority_queue *: CCC_priority_queue_update)((container_pointer), \ - update_args) + update_arguments) -#define CCC_private_increase(container_pointer, increase_args...) \ +#define CCC_private_increase(container_pointer, increase_arguments...) \ _Generic((container_pointer), \ CCC_Flat_priority_queue *: CCC_flat_priority_queue_increase, \ CCC_Priority_queue *: CCC_priority_queue_increase)( \ - (container_pointer), increase_args) + (container_pointer), increase_arguments) -#define CCC_private_decrease(container_pointer, decrease_args...) \ +#define CCC_private_decrease(container_pointer, decrease_arguments...) \ _Generic((container_pointer), \ CCC_Flat_priority_queue *: CCC_flat_priority_queue_decrease, \ CCC_Priority_queue *: CCC_priority_queue_decrease)( \ - (container_pointer), decrease_args) + (container_pointer), decrease_arguments) #define CCC_private_extract(container_pointer, container_array_pointer...) \ _Generic((container_pointer), \ @@ -802,21 +803,21 @@ the appropriate range from the selections. */ CCC_Handle_range_reverse const *: CCC_array_range_reverse_end)( \ (range_reverse_pointer)) -#define CCC_private_splice(container_pointer, splice_args...) \ +#define CCC_private_splice(container_pointer, splice_arguments...) \ _Generic((container_pointer), \ CCC_Singly_linked_list *: CCC_singly_linked_list_splice, \ CCC_Singly_linked_list const *: CCC_singly_linked_list_splice, \ CCC_Doubly_linked_list *: CCC_doubly_linked_list_splice, \ CCC_Doubly_linked_list const *: CCC_doubly_linked_list_splice)( \ - (container_pointer), splice_args) + (container_pointer), splice_arguments) -#define CCC_private_splice_range(container_pointer, splice_range_args...) \ +#define CCC_private_splice_range(container_pointer, splice_range_arguments...) \ _Generic((container_pointer), \ CCC_Singly_linked_list *: CCC_singly_linked_list_splice_range, \ CCC_Singly_linked_list const *: CCC_singly_linked_list_splice_range, \ CCC_Doubly_linked_list *: CCC_doubly_linked_list_splice_range, \ CCC_Doubly_linked_list const *: CCC_doubly_linked_list_splice_range)( \ - (container_pointer), splice_range_args) + (container_pointer), splice_range_arguments) /*=================== Memory Management =======================*/ @@ -872,7 +873,7 @@ the appropriate range from the selections. */ (container_pointer)__VA_OPT__(, __VA_ARGS__)) #define CCC_private_clear_and_free_reserve(container_pointer, \ - destructor_and_free_args...) \ + destructor_and_free_arguments...) \ _Generic((container_pointer), \ CCC_Bitset *: CCC_bitset_clear_and_free_reserve, \ CCC_Buffer *: CCC_buffer_clear_and_free_reserve, \ @@ -884,7 +885,7 @@ the appropriate range from the selections. */ CCC_Flat_double_ended_queue \ *: CCC_flat_double_ended_queue_clear_and_free_reserve, \ CCC_Array_tree_map *: CCC_array_tree_map_clear_and_free_reserve)( \ - (container_pointer), destructor_and_free_args) + (container_pointer), destructor_and_free_arguments) /*=================== Standard Getters Interface =======================*/ diff --git a/ccc/singly_linked_list.h b/ccc/singly_linked_list.h index 689fbf28..4052c958 100644 --- a/ccc/singly_linked_list.h +++ b/ccc/singly_linked_list.h @@ -399,45 +399,54 @@ linked list container. Check for namespace clashes before name shortening. */ #ifdef SINGLY_LINKED_LIST_USING_NAMESPACE_CCC typedef CCC_Singly_linked_list_node singly_linked_list_node; typedef CCC_Singly_linked_list Singly_linked_list; -# define singly_linked_list_initialize(args...) \ - CCC_singly_linked_list_initialize(args) -# define singly_linked_list_from(args...) CCC_singly_linked_list_from(args) -# define singly_linked_list_emplace_front(args...) \ - CCC_singly_linked_list_emplace_front(args) -# define singly_linked_list_push_front(args...) \ - CCC_singly_linked_list_push_front(args) -# define singly_linked_list_front(args...) CCC_singly_linked_list_front(args) -# define singly_linked_list_pop_front(args...) \ - CCC_singly_linked_list_pop_front(args) -# define singly_linked_list_splice(args...) \ - CCC_singly_linked_list_splice(args) -# define singly_linked_list_splice_range(args...) \ - CCC_singly_linked_list_splice_range(args) -# define singly_linked_list_extract(args...) \ - CCC_singly_linked_list_extract(args) -# define singly_linked_list_extract_range(args...) \ - CCC_singly_linked_list_extract_range(args) -# define singly_linked_list_erase(args...) CCC_singly_linked_list_erase(args) -# define singly_linked_list_erase_range(args...) \ - CCC_singly_linked_list_erase_range(args) -# define singly_linked_list_sort(args...) CCC_singly_linked_list_sort(args) -# define singly_linked_list_insert_sorted(args...) \ - CCC_singly_linked_list_insert_sorted(args) -# define singly_linked_list_is_sorted(args...) \ - CCC_singly_linked_list_is_sorted(args) -# define singly_linked_list_begin(args...) CCC_singly_linked_list_begin(args) -# define singly_linked_list_node_begin(args...) \ - CCC_singly_linked_list_node_begin(args) -# define singly_linked_list_node_before_begin(args...) \ - CCC_singly_linked_list_node_before_begin(args) -# define singly_linked_list_end(args...) CCC_singly_linked_list_end(args) -# define singly_linked_list_next(args...) CCC_singly_linked_list_next(args) -# define singly_linked_list_count(args...) CCC_singly_linked_list_count(args) -# define singly_linked_list_is_empty(args...) \ - CCC_singly_linked_list_is_empty(args) -# define singly_linked_list_validate(args...) \ - CCC_singly_linked_list_validate(args) -# define singly_linked_list_clear(args...) CCC_singly_linked_list_clear(args) +# define singly_linked_list_initialize(arguments...) \ + CCC_singly_linked_list_initialize(arguments) +# define singly_linked_list_from(arguments...) \ + CCC_singly_linked_list_from(arguments) +# define singly_linked_list_emplace_front(arguments...) \ + CCC_singly_linked_list_emplace_front(arguments) +# define singly_linked_list_push_front(arguments...) \ + CCC_singly_linked_list_push_front(arguments) +# define singly_linked_list_front(arguments...) \ + CCC_singly_linked_list_front(arguments) +# define singly_linked_list_pop_front(arguments...) \ + CCC_singly_linked_list_pop_front(arguments) +# define singly_linked_list_splice(arguments...) \ + CCC_singly_linked_list_splice(arguments) +# define singly_linked_list_splice_range(arguments...) \ + CCC_singly_linked_list_splice_range(arguments) +# define singly_linked_list_extract(arguments...) \ + CCC_singly_linked_list_extract(arguments) +# define singly_linked_list_extract_range(arguments...) \ + CCC_singly_linked_list_extract_range(arguments) +# define singly_linked_list_erase(arguments...) \ + CCC_singly_linked_list_erase(arguments) +# define singly_linked_list_erase_range(arguments...) \ + CCC_singly_linked_list_erase_range(arguments) +# define singly_linked_list_sort(arguments...) \ + CCC_singly_linked_list_sort(arguments) +# define singly_linked_list_insert_sorted(arguments...) \ + CCC_singly_linked_list_insert_sorted(arguments) +# define singly_linked_list_is_sorted(arguments...) \ + CCC_singly_linked_list_is_sorted(arguments) +# define singly_linked_list_begin(arguments...) \ + CCC_singly_linked_list_begin(arguments) +# define singly_linked_list_node_begin(arguments...) \ + CCC_singly_linked_list_node_begin(arguments) +# define singly_linked_list_node_before_begin(arguments...) \ + CCC_singly_linked_list_node_before_begin(arguments) +# define singly_linked_list_end(arguments...) \ + CCC_singly_linked_list_end(arguments) +# define singly_linked_list_next(arguments...) \ + CCC_singly_linked_list_next(arguments) +# define singly_linked_list_count(arguments...) \ + CCC_singly_linked_list_count(arguments) +# define singly_linked_list_is_empty(arguments...) \ + CCC_singly_linked_list_is_empty(arguments) +# define singly_linked_list_validate(arguments...) \ + CCC_singly_linked_list_validate(arguments) +# define singly_linked_list_clear(arguments...) \ + CCC_singly_linked_list_clear(arguments) #endif /* SINGLY_LINKED_LIST_USING_NAMESPACE_CCC */ #endif /* CCC_FORWARD_LIST_H */ diff --git a/ccc/traits.h b/ccc/traits.h index 58aa3b6a..5f79a586 100644 --- a/ccc/traits.h +++ b/ccc/traits.h @@ -44,93 +44,97 @@ control flow is needed. */ /** @brief Insert an element and obtain the old value if Occupied. @param[in] container_pointer a pointer to the container. -@param swap_args args depend on container. +@param swap_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_swap_entry(container_pointer, swap_args...) \ - CCC_private_swap_entry(container_pointer, swap_args) +#define CCC_swap_entry(container_pointer, swap_arguments...) \ + CCC_private_swap_entry(container_pointer, swap_arguments) /** @brief Insert an element and obtain the old value if Occupied. @param[in] container_pointer a pointer to the container. -@param swap_args args depend on container. +@param swap_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_swap_entry_wrap(container_pointer, swap_args...) \ - CCC_private_swap_entry_wrap(container_pointer, swap_args) +#define CCC_swap_entry_wrap(container_pointer, swap_arguments...) \ + CCC_private_swap_entry_wrap(container_pointer, swap_arguments) /** @brief Insert an element and obtain the old value if Occupied. @param[in] container_pointer a pointer to the container. -@param swap_args args depend on container. +@param swap_arguments arguments depend on container. @return a handle depending on container specific context. See container documentation for specific behavior. */ -#define CCC_swap_handle(container_pointer, swap_args...) \ - CCC_private_swap_handle(container_pointer, swap_args) +#define CCC_swap_handle(container_pointer, swap_arguments...) \ + CCC_private_swap_handle(container_pointer, swap_arguments) /** @brief Insert an element and obtain the old value if Occupied. @param[in] container_pointer a pointer to the container. -@param swap_args args depend on container. +@param swap_arguments arguments depend on container. @return a handle depending on container specific context. See container documentation for specific behavior. */ -#define CCC_swap_handle_wrap(container_pointer, swap_args...) \ - CCC_private_swap_handle_wrap(container_pointer, swap_args) +#define CCC_swap_handle_wrap(container_pointer, swap_arguments...) \ + CCC_private_swap_handle_wrap(container_pointer, swap_arguments) /** @brief Insert an element if the entry is Vacant. @param[in] container_pointer a pointer to the container. -@param try_insert_args args depend on container. +@param try_insert_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_try_insert(container_pointer, try_insert_args...) \ - CCC_private_try_insert(container_pointer, try_insert_args) +#define CCC_try_insert(container_pointer, try_insert_arguments...) \ + CCC_private_try_insert(container_pointer, try_insert_arguments) /** @brief Insert an element if the entry is Vacant. @param[in] container_pointer a pointer to the container. -@param try_insert_args args depend on container. +@param try_insert_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_try_insert_wrap(container_pointer, try_insert_args...) \ - CCC_private_try_insert_wrap(container_pointer, try_insert_args) +#define CCC_try_insert_wrap(container_pointer, try_insert_arguments...) \ + CCC_private_try_insert_wrap(container_pointer, try_insert_arguments) /** @brief Insert an element or overwrite the Occupied entry. @param[in] container_pointer a pointer to the container. -@param insert_or_assign_args args depend on container. +@param insert_or_assign_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_insert_or_assign(container_pointer, insert_or_assign_args...) \ - CCC_private_insert_or_assign(container_pointer, insert_or_assign_args) +#define CCC_insert_or_assign(container_pointer, insert_or_assign_arguments...) \ + CCC_private_insert_or_assign(container_pointer, insert_or_assign_arguments) /** @brief Insert an element or overwrite the Occupied entry. @param[in] container_pointer a pointer to the container. -@param insert_or_assign_args args depend on container. +@param insert_or_assign_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_insert_or_assign_wrap(container_pointer, insert_or_assign_args...) \ - CCC_private_insert_or_assign_wrap(container_pointer, insert_or_assign_args) +#define CCC_insert_or_assign_wrap(container_pointer, \ + insert_or_assign_arguments...) \ + CCC_private_insert_or_assign_wrap(container_pointer, \ + insert_or_assign_arguments) /** @brief Remove an element and retain access to its value. @param[in] container_pointer a pointer to the container. -@param remove_key_value_args args depend on container. +@param remove_key_value_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_remove_key_value(container_pointer, remove_key_value_args...) \ - CCC_private_remove_key_value(container_pointer, remove_key_value_args) +#define CCC_remove_key_value(container_pointer, remove_key_value_arguments...) \ + CCC_private_remove_key_value(container_pointer, remove_key_value_arguments) /** @brief Remove an element and retain access to its value. @param[in] container_pointer a pointer to the container. -@param remove_key_value_args args depend on container. +@param remove_key_value_arguments arguments depend on container. @return an entry depending on container specific context. See container documentation for specific behavior. */ -#define CCC_remove_key_value_wrap(container_pointer, remove_key_value_args...) \ - CCC_private_remove_key_value_wrap(container_pointer, remove_key_value_args) +#define CCC_remove_key_value_wrap(container_pointer, \ + remove_key_value_arguments...) \ + CCC_private_remove_key_value_wrap(container_pointer, \ + remove_key_value_arguments) /** @brief Obtain a container specific entry for the Entry Interface. @param[in] container_pointer a pointer to the container. @@ -182,39 +186,39 @@ See container documentation for specific behavior. */ /** @brief Modify an entry if Occupied. @param[in] entry_pointer a pointer to the container. @param[in] modify a modification function. -@param[in] context_args context data for mod_fn. +@param[in] context_arguments context data for mod_fn. @return a reference to the modified entry if Occupied or original if Vacant. See container documentation for specific behavior. */ -#define CCC_and_modify_context(entry_pointer, modify, context_args...) \ - CCC_private_and_modify_context(entry_pointer, modify, context_args) +#define CCC_and_modify_context(entry_pointer, modify, context_arguments...) \ + CCC_private_and_modify_context(entry_pointer, modify, context_arguments) /** @brief Insert new element or overwrite old element. @param[in] entry_pointer a pointer to the container. -@param insert_entry_args args depend on container. +@param insert_entry_arguments arguments depend on container. @return an reference to the inserted element. See container documentation for specific behavior. */ -#define CCC_insert_entry(entry_pointer, insert_entry_args...) \ - CCC_private_insert_entry(entry_pointer, insert_entry_args) +#define CCC_insert_entry(entry_pointer, insert_entry_arguments...) \ + CCC_private_insert_entry(entry_pointer, insert_entry_arguments) /** @brief Insert new element or overwrite old element. @param[in] array_pointer a pointer to the container. -@param insert_array_args args depend on container. +@param insert_array_arguments arguments depend on container. @return an reference to the inserted element. See container documentation for specific behavior. */ -#define CCC_insert_handle(array_pointer, insert_array_args...) \ - CCC_private_insert_handle(array_pointer, insert_array_args) +#define CCC_insert_handle(array_pointer, insert_array_arguments...) \ + CCC_private_insert_handle(array_pointer, insert_array_arguments) /** @brief Insert new element if the entry is Vacant. @param[in] entry_pointer a pointer to the container. -@param or_insert_args args depend on container. +@param or_insert_arguments arguments depend on container. @return an reference to the old element or new element if entry was Vacant. See container documentation for specific behavior. */ -#define CCC_or_insert(entry_pointer, or_insert_args...) \ - CCC_private_or_insert(entry_pointer, or_insert_args) +#define CCC_or_insert(entry_pointer, or_insert_arguments...) \ + CCC_private_or_insert(entry_pointer, or_insert_arguments) /** @brief Remove the element if the entry is Occupied. @param[in] entry_pointer a pointer to the container. @@ -300,39 +304,40 @@ Push, pop, and view elements in sorted or unsorted containers. */ /** @brief Push an element into a container. @param[in] container_pointer a pointer to the container. -@param push_args depend on container. +@param push_arguments depend on container. @return a reference to the pushed element. See container documentation for specific behavior. */ -#define CCC_push(container_pointer, push_args...) \ - CCC_private_push(container_pointer, push_args) +#define CCC_push(container_pointer, push_arguments...) \ + CCC_private_push(container_pointer, push_arguments) /** @brief Push an element to the back of a container. @param[in] container_pointer a pointer to the container. -@param push_args depend on container. +@param push_arguments depend on container. @return a reference to the pushed element. See container documentation for specific behavior. */ -#define CCC_push_back(container_pointer, push_args...) \ - CCC_private_push_back(container_pointer, push_args) +#define CCC_push_back(container_pointer, push_arguments...) \ + CCC_private_push_back(container_pointer, push_arguments) /** @brief Push an element to the front of a container. @param[in] container_pointer a pointer to the container. -@param push_args depend on container. +@param push_arguments depend on container. @return a reference to the pushed element. See container documentation for specific behavior. */ -#define CCC_push_front(container_pointer, push_args...) \ - CCC_private_push_front(container_pointer, push_args) +#define CCC_push_front(container_pointer, push_arguments...) \ + CCC_private_push_front(container_pointer, push_arguments) /** @brief Pop an element from a container. @param[in] container_pointer a pointer to the container. -@param[in] pop_args any supplementary args a container may have for the pop. +@param[in] pop_arguments any supplementary arguments a container may have for +the pop. @return a result of the pop operation. See container documentation for specific behavior. */ -#define CCC_pop(container_pointer, pop_args...) \ - CCC_private_pop(container_pointer, pop_args) +#define CCC_pop(container_pointer, pop_arguments...) \ + CCC_private_pop(container_pointer, pop_arguments) /** @brief Pop an element from the front of a container. @param[in] container_pointer a pointer to the container. @@ -366,22 +371,22 @@ See container documentation for specific behavior. */ /** @brief Splice an element from one position to another in the same or a different container. @param[in] container_pointer a pointer to the container. -@param splice_args are container specific. +@param splice_arguments are container specific. @return the result of the splice. See container documentation for specific behavior. */ -#define CCC_splice(container_pointer, splice_args...) \ - CCC_private_splice(container_pointer, splice_args) +#define CCC_splice(container_pointer, splice_arguments...) \ + CCC_private_splice(container_pointer, splice_arguments) /** @brief Splice a range of elements from one position to another in the same or a different container. @param[in] container_pointer a pointer to the container. -@param splice_args are container specific. +@param splice_arguments are container specific. @return the result of the splice. See container documentation for specific behavior. */ -#define CCC_splice_range(container_pointer, splice_args...) \ - CCC_private_splice_range(container_pointer, splice_args) +#define CCC_splice_range(container_pointer, splice_arguments...) \ + CCC_private_splice_range(container_pointer, splice_arguments) /**@}*/ @@ -391,51 +396,51 @@ Interface to support generic priority queue operations. */ /** @brief Update the value of an element known to be in a container. @param[in] container_pointer a pointer to the container. -@param update_args depend on the container. +@param update_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_update(container_pointer, update_args...) \ - CCC_private_update(container_pointer, update_args) +#define CCC_update(container_pointer, update_arguments...) \ + CCC_private_update(container_pointer, update_arguments) /** @brief Increase the value of an element known to be in a container. @param[in] container_pointer a pointer to the container. -@param increase_args depend on the container. +@param increase_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_increase(container_pointer, increase_args...) \ - CCC_private_increase(container_pointer, increase_args) +#define CCC_increase(container_pointer, increase_arguments...) \ + CCC_private_increase(container_pointer, increase_arguments) /** @brief Decrease the value of an element known to be in a container. @param[in] container_pointer a pointer to the container. -@param decrease_args depend on the container. +@param decrease_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_decrease(container_pointer, decrease_args...) \ - CCC_private_decrease(container_pointer, decrease_args) +#define CCC_decrease(container_pointer, decrease_arguments...) \ + CCC_private_decrease(container_pointer, decrease_arguments) /** @brief Erase an element known to be in a container. @param[in] container_pointer a pointer to the container. -@param erase_args depend on the container. +@param erase_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_erase(container_pointer, erase_args...) \ - CCC_private_erase(container_pointer, erase_args) +#define CCC_erase(container_pointer, erase_arguments...) \ + CCC_private_erase(container_pointer, erase_arguments) /** @brief Extract an element known to be in a container (does not free). @param[in] container_pointer a pointer to the container. -@param extract_args depend on the container. +@param extract_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_extract(container_pointer, extract_args...) \ - CCC_private_extract(container_pointer, extract_args) +#define CCC_extract(container_pointer, extract_arguments...) \ + CCC_private_extract(container_pointer, extract_arguments) /** @brief Extract elements known to be in a container (does not free). @param[in] container_pointer a pointer to the container. -@param extract_args depend on the container. +@param extract_arguments depend on the container. See container documentation for specific behavior. */ -#define CCC_extract_range(container_pointer, extract_args...) \ - CCC_private_extract_range(container_pointer, extract_args) +#define CCC_extract_range(container_pointer, extract_arguments...) \ + CCC_private_extract_range(container_pointer, extract_arguments) /**@}*/ @@ -495,39 +500,41 @@ See container documentation for specific behavior. */ /** @brief Obtain a range of values from a container. @param[in] container_pointer a pointer to the container. -@param range_args are container specific. +@param range_arguments are container specific. @return the range. See container documentation for specific behavior. */ -#define CCC_equal_range(container_pointer, range_args...) \ - CCC_private_equal_range(container_pointer, range_args) +#define CCC_equal_range(container_pointer, range_arguments...) \ + CCC_private_equal_range(container_pointer, range_arguments) /** @brief Obtain a range of values from a container. @param[in] container_pointer a pointer to the container. -@param range_args are container specific. +@param range_arguments are container specific. @return a reference to the range. See container documentation for specific behavior. */ -#define CCC_equal_range_wrap(container_pointer, range_args...) \ - CCC_private_equal_range_wrap(container_pointer, range_args) +#define CCC_equal_range_wrap(container_pointer, range_arguments...) \ + CCC_private_equal_range_wrap(container_pointer, range_arguments) /** @brief Obtain a range_reverse of values from a container. @param[in] container_pointer a pointer to the container. -@param range_reverse_args are container specific. +@param range_reverse_arguments are container specific. @return the range_reverse. See container documentation for specific behavior. */ -#define CCC_equal_range_reverse(container_pointer, range_reverse_args...) \ - CCC_private_equal_range_reverse(container_pointer, range_reverse_args) +#define CCC_equal_range_reverse(container_pointer, range_reverse_arguments...) \ + CCC_private_equal_range_reverse(container_pointer, range_reverse_arguments) /** @brief Obtain a range_reverse of values from a container. @param[in] container_pointer a pointer to the container. -@param range_reverse_args are container specific. +@param range_reverse_arguments are container specific. @return a reference to the range_reverse. See container documentation for specific behavior. */ -#define CCC_equal_range_reverse_wrap(container_pointer, range_reverse_args...) \ - CCC_private_equal_range_reverse_wrap(container_pointer, range_reverse_args) +#define CCC_equal_range_reverse_wrap(container_pointer, \ + range_reverse_arguments...) \ + CCC_private_equal_range_reverse_wrap(container_pointer, \ + range_reverse_arguments) /** @brief Obtain the beginning of the range iterator. @param[in] range_pointer a pointer to the type of range. @@ -586,36 +593,37 @@ See container documentation for specific behavior. */ /** @brief Clears the container without freeing the underlying buffer. @param[in] container_pointer a pointer to the container. -@param[in] destructor_args optional function to be called on each element. +@param[in] destructor_arguments optional function to be called on each element. @return the result of the operation. See container documentation for specific behavior. */ -#define CCC_clear(container_pointer, destructor_args...) \ - CCC_private_clear(container_pointer, destructor_args) +#define CCC_clear(container_pointer, destructor_arguments...) \ + CCC_private_clear(container_pointer, destructor_arguments) /** @brief Clears the container and frees the underlying buffer. @param[in] container_pointer a pointer to the container. -@param[in] destructor_and_free_args optional function to be called on each +@param[in] destructor_and_free_arguments optional function to be called on each element. @return the result of the operation. See container documentation for specific behavior. */ -#define CCC_clear_and_free(container_pointer, destructor_and_free_args...) \ - CCC_private_clear_and_free(container_pointer, destructor_and_free_args) +#define CCC_clear_and_free(container_pointer, \ + destructor_and_free_arguments...) \ + CCC_private_clear_and_free(container_pointer, destructor_and_free_arguments) /** @brief Clears the container previously reserved and frees its underlying buffer. Covers the case of a one-time memory reserved container that does not otherwise have permissions over its own memory to resize or free. @param[in] container_pointer a pointer to the container. -@param[in] destructor_and_free_args optional destructor function to be called -on each element and the required allocation function to free memory. +@param[in] destructor_and_free_arguments optional destructor function to be +called on each element and the required allocation function to free memory. @return the result of the operation. See container documentation for specific behavior. */ #define CCC_clear_and_free_reserve(container_pointer, \ - destructor_and_free_args...) \ + destructor_and_free_arguments...) \ CCC_private_clear_and_free_reserve(container_pointer, \ - destructor_and_free_args) + destructor_and_free_arguments) /**@}*/ @@ -655,80 +663,84 @@ See container documentation for specific behavior. */ /** Define this preprocessor directive to shorten trait names. */ #ifdef TRAITS_USING_NAMESPACE_CCC -# define swap_entry(args...) CCC_swap_entry(args) -# define swap_entry_wrap(args...) CCC_swap_entry_wrap(args) -# define swap_handle(args...) CCC_swap_handle(args) -# define swap_handle_wrap(args...) CCC_swap_handle_wrap(args) -# define try_insert(args...) CCC_try_insert(args) -# define insert_or_assign(args...) CCC_insert_or_assign(args) -# define insert_or_assign_wrap(args...) CCC_insert_or_assign_wrap(args) -# define try_insert_wrap(args...) CCC_try_insert_wrap(args) -# define remove_key_value(args...) CCC_remove_key_value(args) -# define remove_key_value_wrap(args...) CCC_remove_key_value_wrap(args) -# define remove_entry(args...) CCC_remove_entry(args) -# define remove_entry_wrap(args...) CCC_remove_entry_wrap(args) -# define remove_handle(args...) CCC_remove_handle(args) -# define remove_handle_wrap(args...) CCC_remove_handle_wrap(args) -# define entry(args...) CCC_entry(args) -# define entry_wrap(args...) CCC_entry_wrap(args) -# define handle(args...) CCC_handle(args) -# define handle_wrap(args...) CCC_handle_wrap(args) -# define or_insert(args...) CCC_or_insert(args) -# define insert_entry(args...) CCC_insert_entry(args) -# define insert_handle(args...) CCC_insert_handle(args) -# define and_modify(args...) CCC_and_modify(args) -# define and_modify_context(args...) CCC_and_modify_context(args) -# define occupied(args...) CCC_occupied(args) -# define insert_error(args...) CCC_insert_error(args) -# define unwrap(args...) CCC_unwrap(args) - -# define push(args...) CCC_push(args) -# define push_back(args...) CCC_push_back(args) -# define push_front(args...) CCC_push_front(args) -# define pop(args...) CCC_pop(args) -# define pop_front(args...) CCC_pop_front(args) -# define pop_back(args...) CCC_pop_back(args) -# define front(args...) CCC_front(args) -# define back(args...) CCC_back(args) -# define update(args...) CCC_update(args) -# define increase(args...) CCC_increase(args) -# define decrease(args...) CCC_decrease(args) -# define erase(args...) CCC_erase(args) -# define extract(args...) CCC_extract(args) -# define extract_range(args...) CCC_extract_range(args) - -# define get_key_value(args...) CCC_get_key_value(args) -# define get_mut(args...) CCC_get_key_value_mut(args) -# define contains(args...) CCC_contains(args) - -# define begin(args...) CCC_begin(args) -# define reverse_begin(args...) CCC_reverse_begin(args) -# define next(args...) CCC_next(args) -# define reverse_next(args...) CCC_reverse_next(args) -# define end(args...) CCC_end(args) -# define reverse_end(args...) CCC_reverse_end(args) - -# define equal_range(args...) CCC_equal_range(args) -# define equal_range_reverse(args...) CCC_equal_range_reverse(args) -# define equal_range_wrap(args...) CCC_equal_range_wrap(args) -# define equal_range_reverse_wrap(args...) CCC_equal_range_reverse_wrap(args) -# define range_begin(args...) CCC_range_begin(args) -# define range_end(args...) CCC_range_end(args) -# define range_reverse_begin(args...) CCC_range_reverse_begin(args) -# define range_reverse_end(args...) CCC_range_reverse_end(args) -# define splice(args...) CCC_splice(args) -# define splice_range(args...) CCC_splice_range(args) - -# define copy(args...) CCC_copy(args) -# define reserve(args...) CCC_reserve(args) -# define clear(args...) CCC_clear(args) -# define clear_and_free(args...) CCC_clear_and_free(args) -# define clear_and_free_reserve(args...) CCC_clear_and_free_reserve(args) - -# define count(args...) CCC_count(args) -# define capacity(args...) CCC_capacity(args) -# define is_empty(args...) CCC_is_empty(args) -# define validate(args...) CCC_validate(args) +# define swap_entry(arguments...) CCC_swap_entry(arguments) +# define swap_entry_wrap(arguments...) CCC_swap_entry_wrap(arguments) +# define swap_handle(arguments...) CCC_swap_handle(arguments) +# define swap_handle_wrap(arguments...) CCC_swap_handle_wrap(arguments) +# define try_insert(arguments...) CCC_try_insert(arguments) +# define insert_or_assign(arguments...) CCC_insert_or_assign(arguments) +# define insert_or_assign_wrap(arguments...) \ + CCC_insert_or_assign_wrap(arguments) +# define try_insert_wrap(arguments...) CCC_try_insert_wrap(arguments) +# define remove_key_value(arguments...) CCC_remove_key_value(arguments) +# define remove_key_value_wrap(arguments...) \ + CCC_remove_key_value_wrap(arguments) +# define remove_entry(arguments...) CCC_remove_entry(arguments) +# define remove_entry_wrap(arguments...) CCC_remove_entry_wrap(arguments) +# define remove_handle(arguments...) CCC_remove_handle(arguments) +# define remove_handle_wrap(arguments...) CCC_remove_handle_wrap(arguments) +# define entry(arguments...) CCC_entry(arguments) +# define entry_wrap(arguments...) CCC_entry_wrap(arguments) +# define handle(arguments...) CCC_handle(arguments) +# define handle_wrap(arguments...) CCC_handle_wrap(arguments) +# define or_insert(arguments...) CCC_or_insert(arguments) +# define insert_entry(arguments...) CCC_insert_entry(arguments) +# define insert_handle(arguments...) CCC_insert_handle(arguments) +# define and_modify(arguments...) CCC_and_modify(arguments) +# define and_modify_context(arguments...) CCC_and_modify_context(arguments) +# define occupied(arguments...) CCC_occupied(arguments) +# define insert_error(arguments...) CCC_insert_error(arguments) +# define unwrap(arguments...) CCC_unwrap(arguments) + +# define push(arguments...) CCC_push(arguments) +# define push_back(arguments...) CCC_push_back(arguments) +# define push_front(arguments...) CCC_push_front(arguments) +# define pop(arguments...) CCC_pop(arguments) +# define pop_front(arguments...) CCC_pop_front(arguments) +# define pop_back(arguments...) CCC_pop_back(arguments) +# define front(arguments...) CCC_front(arguments) +# define back(arguments...) CCC_back(arguments) +# define update(arguments...) CCC_update(arguments) +# define increase(arguments...) CCC_increase(arguments) +# define decrease(arguments...) CCC_decrease(arguments) +# define erase(arguments...) CCC_erase(arguments) +# define extract(arguments...) CCC_extract(arguments) +# define extract_range(arguments...) CCC_extract_range(arguments) + +# define get_key_value(arguments...) CCC_get_key_value(arguments) +# define get_mut(arguments...) CCC_get_key_value_mut(arguments) +# define contains(arguments...) CCC_contains(arguments) + +# define begin(arguments...) CCC_begin(arguments) +# define reverse_begin(arguments...) CCC_reverse_begin(arguments) +# define next(arguments...) CCC_next(arguments) +# define reverse_next(arguments...) CCC_reverse_next(arguments) +# define end(arguments...) CCC_end(arguments) +# define reverse_end(arguments...) CCC_reverse_end(arguments) + +# define equal_range(arguments...) CCC_equal_range(arguments) +# define equal_range_reverse(arguments...) CCC_equal_range_reverse(arguments) +# define equal_range_wrap(arguments...) CCC_equal_range_wrap(arguments) +# define equal_range_reverse_wrap(arguments...) \ + CCC_equal_range_reverse_wrap(arguments) +# define range_begin(arguments...) CCC_range_begin(arguments) +# define range_end(arguments...) CCC_range_end(arguments) +# define range_reverse_begin(arguments...) CCC_range_reverse_begin(arguments) +# define range_reverse_end(arguments...) CCC_range_reverse_end(arguments) +# define splice(arguments...) CCC_splice(arguments) +# define splice_range(arguments...) CCC_splice_range(arguments) + +# define copy(arguments...) CCC_copy(arguments) +# define reserve(arguments...) CCC_reserve(arguments) +# define clear(arguments...) CCC_clear(arguments) +# define clear_and_free(arguments...) CCC_clear_and_free(arguments) +# define clear_and_free_reserve(arguments...) \ + CCC_clear_and_free_reserve(arguments) + +# define count(arguments...) CCC_count(arguments) +# define capacity(arguments...) CCC_capacity(arguments) +# define is_empty(arguments...) CCC_is_empty(arguments) +# define validate(arguments...) CCC_validate(arguments) #endif /* TRAITS_USING_NAMESPACE_CCC */ #endif /* CCC_TRAITS_H */ diff --git a/ccc/tree_map.h b/ccc/tree_map.h index cbfd4024..0366480b 100644 --- a/ccc/tree_map.h +++ b/ccc/tree_map.h @@ -726,50 +726,61 @@ NULL. */ typedef CCC_Tree_map_node Tree_map_node; typedef CCC_Tree_map Tree_map; typedef CCC_Tree_map_entry Tree_map_entry; -# define tree_map_initialize(args...) CCC_tree_map_initialize(args) -# define tree_map_from(args...) CCC_tree_map_from(args) -# define tree_map_and_modify_with(args...) CCC_tree_map_and_modify_with(args) -# define tree_map_or_insert_with(args...) CCC_tree_map_or_insert_with(args) -# define tree_map_insert_entry_with(args...) \ - CCC_tree_map_insert_entry_with(args) -# define tree_map_try_insert_with(args...) CCC_tree_map_try_insert_with(args) -# define tree_map_insert_or_assign(args...) \ - CCC_tree_map_insert_or_assign(args) -# define tree_map_insert_or_assign_wrap(args...) \ - CCC_tree_map_insert_or_assign_wrap(args) -# define tree_map_insert_or_assign_with(args...) \ - CCC_tree_map_insert_or_assign_with(args) -# define tree_map_swap_entry_wrap(args...) CCC_tree_map_swap_entry_wrap(args) -# define tree_map_remove_key_value_wrap(args...) \ - CCC_tree_map_remove_key_value_wrap(args) -# define tree_map_remove_entry_wrap(args...) \ - CCC_tree_map_remove_entry_wrap(args) -# define tree_map_entry_wrap(args...) CCC_tree_map_entry_wrap(args) -# define tree_map_and_modify_wrap(args...) CCC_tree_map_and_modify_wrap(args) -# define tree_map_and_modify_context_wrap(args...) \ - CCC_tree_map_and_modify_context_wrap(args) -# define tree_map_contains(args...) CCC_tree_map_contains(args) -# define tree_map_get_key_value(args...) CCC_tree_map_get_key_value(args) -# define tree_map_get_mut(args...) CCC_tree_map_get_mut(args) -# define tree_map_swap_entry(args...) CCC_tree_map_swap_entry(args) -# define tree_map_remove_key_value(args...) \ - CCC_tree_map_remove_key_value(args) -# define tree_map_entry(args...) CCC_tree_map_entry(args) -# define tree_map_remove_entry(args...) CCC_tree_map_remove_entry(args) -# define tree_map_or_insert(args...) CCC_tree_map_or_insert(args) -# define tree_map_insert_entry(args...) CCC_tree_map_insert_entry(args) -# define tree_map_unwrap(args...) CCC_tree_map_unwrap(args) -# define tree_map_unwrap_mut(args...) CCC_tree_map_unwrap_mut(args) -# define tree_map_begin(args...) CCC_tree_map_begin(args) -# define tree_map_next(args...) CCC_tree_map_next(args) -# define tree_map_reverse_begin(args...) CCC_tree_map_reverse_begin(args) -# define tree_map_reverse_next(args...) CCC_tree_map_reverse_next(args) -# define tree_map_end(args...) CCC_tree_map_end(args) -# define tree_map_reverse_end(args...) CCC_tree_map_reverse_end(args) -# define tree_map_count(args...) CCC_tree_map_count(args) -# define tree_map_is_empty(args...) CCC_tree_map_is_empty(args) -# define tree_map_clear(args...) CCC_tree_map_clear(args) -# define tree_map_validate(args...) CCC_tree_map_validate(args) +# define tree_map_initialize(arguments...) CCC_tree_map_initialize(arguments) +# define tree_map_from(arguments...) CCC_tree_map_from(arguments) +# define tree_map_and_modify_with(arguments...) \ + CCC_tree_map_and_modify_with(arguments) +# define tree_map_or_insert_with(arguments...) \ + CCC_tree_map_or_insert_with(arguments) +# define tree_map_insert_entry_with(arguments...) \ + CCC_tree_map_insert_entry_with(arguments) +# define tree_map_try_insert_with(arguments...) \ + CCC_tree_map_try_insert_with(arguments) +# define tree_map_insert_or_assign(arguments...) \ + CCC_tree_map_insert_or_assign(arguments) +# define tree_map_insert_or_assign_wrap(arguments...) \ + CCC_tree_map_insert_or_assign_wrap(arguments) +# define tree_map_insert_or_assign_with(arguments...) \ + CCC_tree_map_insert_or_assign_with(arguments) +# define tree_map_swap_entry_wrap(arguments...) \ + CCC_tree_map_swap_entry_wrap(arguments) +# define tree_map_remove_key_value_wrap(arguments...) \ + CCC_tree_map_remove_key_value_wrap(arguments) +# define tree_map_remove_entry_wrap(arguments...) \ + CCC_tree_map_remove_entry_wrap(arguments) +# define tree_map_entry_wrap(arguments...) CCC_tree_map_entry_wrap(arguments) +# define tree_map_and_modify_wrap(arguments...) \ + CCC_tree_map_and_modify_wrap(arguments) +# define tree_map_and_modify_context_wrap(arguments...) \ + CCC_tree_map_and_modify_context_wrap(arguments) +# define tree_map_contains(arguments...) CCC_tree_map_contains(arguments) +# define tree_map_get_key_value(arguments...) \ + CCC_tree_map_get_key_value(arguments) +# define tree_map_get_mut(arguments...) CCC_tree_map_get_mut(arguments) +# define tree_map_swap_entry(arguments...) CCC_tree_map_swap_entry(arguments) +# define tree_map_remove_key_value(arguments...) \ + CCC_tree_map_remove_key_value(arguments) +# define tree_map_entry(arguments...) CCC_tree_map_entry(arguments) +# define tree_map_remove_entry(arguments...) \ + CCC_tree_map_remove_entry(arguments) +# define tree_map_or_insert(arguments...) CCC_tree_map_or_insert(arguments) +# define tree_map_insert_entry(arguments...) \ + CCC_tree_map_insert_entry(arguments) +# define tree_map_unwrap(arguments...) CCC_tree_map_unwrap(arguments) +# define tree_map_unwrap_mut(arguments...) CCC_tree_map_unwrap_mut(arguments) +# define tree_map_begin(arguments...) CCC_tree_map_begin(arguments) +# define tree_map_next(arguments...) CCC_tree_map_next(arguments) +# define tree_map_reverse_begin(arguments...) \ + CCC_tree_map_reverse_begin(arguments) +# define tree_map_reverse_next(arguments...) \ + CCC_tree_map_reverse_next(arguments) +# define tree_map_end(arguments...) CCC_tree_map_end(arguments) +# define tree_map_reverse_end(arguments...) \ + CCC_tree_map_reverse_end(arguments) +# define tree_map_count(arguments...) CCC_tree_map_count(arguments) +# define tree_map_is_empty(arguments...) CCC_tree_map_is_empty(arguments) +# define tree_map_clear(arguments...) CCC_tree_map_clear(arguments) +# define tree_map_validate(arguments...) CCC_tree_map_validate(arguments) #endif #endif /* CCC_TREE_MAP_H */ diff --git a/tests/checkers.h b/tests/checkers.h index 4fa456c3..ffe95389 100644 --- a/tests/checkers.h +++ b/tests/checkers.h @@ -138,7 +138,7 @@ executed on failure. This should only be used in special cases where such a function is unusable by the end test macro due to scoping. Even then, consider tracking allocations in an array of some sort to be cleaned up upon failure or success in the end test macro. Function calls should be a semicolon -seperated list of calls with their appropriate args. If more complex code +seperated list of calls with their appropriate arguments. If more complex code needs to be written in the cleanup case a code block can be surrounded by {...any code goes here...} braces for the formatting assistance braces provide, though the braces are not required. */ @@ -178,7 +178,7 @@ executed on failure. This should only be used in special cases where such a function is unusable by the end test macro due to scoping. Even then, consider tracking allocations in an array of some sort to be cleaned up upon failure or success in the end test macro. Function calls should be a semicolon seperated -list of calls with their appropriate args. If more complex code needs to be +list of calls with their appropriate arguments. If more complex code needs to be written in the cleanup case a code block can be surrounded by {...any code goes here...} braces for the formatting assistance braces provide, though the braces are not required. */