ordered_multimap.h

Go to the documentation of this file.

 
#ifndef CCC_ORDERED_MULTIMAP_H
#define CCC_ORDERED_MULTIMAP_H
 
#include <stddef.h>
#include "impl/impl_ordered_multimap.h"
#include "types.h"
 
typedef struct ccc_ommap ccc_ordered_multimap;
 
typedef struct ccc_ommap_elem ccc_ommap_elem;
 
typedef union ccc_ommap_entry ccc_ommap_entry;
 
#define ccc_omm_init(omm_name, any_struct_name, ommap_elem_field, key_field,   \
                     key_cmp_fn, alloc_fn, aux)                                \
    ccc_impl_omm_init(omm_name, any_struct_name, ommap_elem_field, key_field,  \
                      key_cmp_fn, alloc_fn, aux)
 
[[nodiscard]] ccc_tribool ccc_omm_contains(ccc_ordered_multimap *mm,
                                           void const *key);
 
[[nodiscard]] void *ccc_omm_get_key_val(ccc_ordered_multimap *mm,
                                        void const *key);
 
[[nodiscard]] ccc_entry ccc_omm_swap_entry(ccc_ordered_multimap *mm,
                                           ccc_ommap_elem *key_val_handle);
 
[[nodiscard]] ccc_entry ccc_omm_try_insert(ccc_ordered_multimap *mm,
                                           ccc_ommap_elem *key_val_handle);
 
#define ccc_omm_try_insert_w(ordered_multimap_ptr, key, lazy_value...)         \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_impl_omm_try_insert_w(ordered_multimap_ptr, key, lazy_value)       \
    }
 
[[nodiscard]] ccc_entry
ccc_omm_insert_or_assign(ccc_ordered_multimap *mm,
                         ccc_ommap_elem *key_val_handle);
 
#define ccc_omm_insert_or_assign_w(ordered_multimap_ptr, key, lazy_value...)   \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_impl_omm_insert_or_assign_w(ordered_multimap_ptr, key, lazy_value) \
    }
 
[[nodiscard]] ccc_entry ccc_omm_remove(ccc_ordered_multimap *mm,
                                       ccc_ommap_elem *out_handle);
 
[[nodiscard]] ccc_ommap_entry ccc_omm_entry(ccc_ordered_multimap *mm,
                                            void const *key);
 
#define ccc_omm_entry_r(ordered_multimap_ptr, key_ptr)                         \
    &(ccc_ommap_entry)                                                         \
    {                                                                          \
        ccc_omm_entry((ordered_multimap_ptr), (key_ptr)).impl                  \
    }
 
[[nodiscard]] ccc_ommap_entry *ccc_omm_and_modify(ccc_ommap_entry *e,
                                                  ccc_any_type_update_fn *fn);
 
[[nodiscard]] ccc_ommap_entry *
ccc_omm_and_modify_aux(ccc_ommap_entry *e, ccc_any_type_update_fn *fn,
                       void *aux);
 
#define ccc_omm_and_modify_w(ordered_multimap_entry_ptr, type_name,            \
                             closure_over_T...)                                \
    &(ccc_ommap_entry)                                                         \
    {                                                                          \
        ccc_impl_omm_and_modify_w(ordered_multimap_entry_ptr, type_name,       \
                                  closure_over_T)                              \
    }
 
[[nodiscard]] void *ccc_omm_or_insert(ccc_ommap_entry const *e,
                                      ccc_ommap_elem *key_val_handle);
 
#define ccc_omm_or_insert_w(ordered_multimap_entry_ptr, lazy_key_value...)     \
    ccc_impl_omm_or_insert_w(ordered_multimap_entry_ptr, lazy_key_value)
 
[[nodiscard]] void *ccc_omm_insert_entry(ccc_ommap_entry const *e,
                                         ccc_ommap_elem *key_val_handle);
 
#define ccc_omm_insert_entry_w(ordered_multimap_entry_ptr, lazy_key_value...)  \
    ccc_impl_omm_insert_entry_w(ordered_multimap_entry_ptr, lazy_key_value)
 
[[nodiscard]] ccc_entry ccc_omm_remove_entry(ccc_ommap_entry *e);
 
[[nodiscard]] ccc_tribool ccc_omm_occupied(ccc_ommap_entry const *e);
 
[[nodiscard]] void *ccc_omm_unwrap(ccc_ommap_entry const *e);
 
[[nodiscard]] ccc_tribool ccc_omm_insert_error(ccc_ommap_entry const *e);
 
[[nodiscard]] ccc_tribool ccc_omm_input_error(ccc_ommap_entry const *e);
 
[[nodiscard]] ccc_entry_status ccc_omm_entry_status(ccc_ommap_entry const *e);
 
ccc_result ccc_omm_pop_max(ccc_ordered_multimap *mm);
 
ccc_result ccc_omm_pop_min(ccc_ordered_multimap *mm);
 
[[nodiscard]] void *ccc_omm_max(ccc_ordered_multimap *mm);
 
[[nodiscard]] void *ccc_omm_min(ccc_ordered_multimap *mm);
 
[[nodiscard]] void *ccc_omm_extract(ccc_ordered_multimap *mm,
                                    ccc_ommap_elem *key_val_handle);
 
[[nodiscard]] ccc_tribool ccc_omm_update(ccc_ordered_multimap *mm,
                                         ccc_ommap_elem *key_val_handle,
                                         ccc_any_type_update_fn *fn, void *aux);
 
[[nodiscard]] ccc_tribool ccc_omm_increase(ccc_ordered_multimap *mm,
                                           ccc_ommap_elem *key_val_handle,
                                           ccc_any_type_update_fn *fn,
                                           void *aux);
 
[[nodiscard]] ccc_tribool ccc_omm_decrease(ccc_ordered_multimap *mm,
                                           ccc_ommap_elem *key_val_handle,
                                           ccc_any_type_update_fn *fn,
                                           void *aux);
 
ccc_result ccc_omm_clear(ccc_ordered_multimap *mm,
                         ccc_any_type_destructor_fn *destructor);
 
[[nodiscard]] ccc_range ccc_omm_equal_range(ccc_ordered_multimap *mm,
                                            void const *begin_key,
                                            void const *end_key);
 
#define ccc_omm_equal_range_r(ordered_multimap_ptr, begin_and_end_key_ptrs...) \
    &(ccc_range)                                                               \
    {                                                                          \
        ccc_omm_equal_range(ordered_multimap_ptr, begin_and_end_key_ptrs).impl \
    }
 
[[nodiscard]] ccc_rrange ccc_omm_equal_rrange(ccc_ordered_multimap *mm,
                                              void const *rbegin_key,
                                              void const *rend_key);
 
#define ccc_omm_equal_rrange_r(ordered_multimap_ptr,                           \
                               rbegin_and_rend_key_ptrs...)                    \
    &(ccc_rrange)                                                              \
    {                                                                          \
        ccc_omm_equal_rrange(ordered_multimap_ptr, rbegin_and_rend_key_ptrs)   \
            .impl                                                              \
    }
 
[[nodiscard]] void *ccc_omm_begin(ccc_ordered_multimap const *mm);
 
[[nodiscard]] void *ccc_omm_rbegin(ccc_ordered_multimap const *mm);
 
[[nodiscard]] void *ccc_omm_next(ccc_ordered_multimap const *mm,
                                 ccc_ommap_elem const *iter_handle);
 
[[nodiscard]] void *ccc_omm_rnext(ccc_ordered_multimap const *mm,
                                  ccc_ommap_elem const *iter_handle);
 
[[nodiscard]] void *ccc_omm_end(ccc_ordered_multimap const *mm);
 
[[nodiscard]] void *ccc_omm_rend(ccc_ordered_multimap const *mm);
 
[[nodiscard]] ccc_tribool ccc_omm_is_empty(ccc_ordered_multimap const *mm);
 
[[nodiscard]] ccc_ucount ccc_omm_size(ccc_ordered_multimap const *mm);
 
[[nodiscard]] ccc_tribool ccc_omm_validate(ccc_ordered_multimap const *mm);
 
#ifdef ORDERED_MULTIMAP_USING_NAMESPACE_CCC
typedef ccc_ommap_elem ommap_elem;
typedef ccc_ordered_multimap ordered_multimap;
typedef ccc_ommap_entry ommap_entry;
#    define omm_and_modify_w(args...) ccc_omm_and_modify_w(args)
#    define omm_or_insert_w(args...) ccc_omm_or_insert_w(args)
#    define omm_insert_entry_w(args...) ccc_omm_insert_entry_w(args)
#    define omm_try_insert_w(args...) ccc_omm_try_insert_w(args)
#    define omm_insert_or_assign_w(args...) ccc_omm_insert_or_assign_w(args)
#    define omm_init(args...) ccc_omm_init(args)
#    define omm_swap_entry(args...) ccc_omm_swap_entry(args)
#    define omm_try_insert(args...) ccc_omm_try_insert(args)
#    define omm_insert_or_assign(args...) ccc_omm_insert_or_assign(args)
#    define omm_remove(args...) ccc_omm_remove(args)
#    define omm_remove_entry(args...) ccc_omm_remove_entry(args)
#    define omm_entry_r(args...) ccc_omm_entry_r(args)
#    define omm_entry(args...) ccc_omm_entry(args)
#    define omm_and_modify(args...) ccc_omm_and_modify(args)
#    define omm_and_modify_aux(args...) ccc_omm_and_modify_aux(args)
#    define omm_or_insert(args...) ccc_omm_or_insert(args)
#    define omm_insert_entry(args...) ccc_omm_insert_entry(args)
#    define omm_unwrap(args...) ccc_omm_unwrap(args)
#    define omm_insert_error(args...) ccc_omm_insert_error(args)
#    define omm_occupied(args...) ccc_omm_occupied(args)
#    define omm_clear(args...) ccc_omm_clear(args)
#    define omm_is_empty(args...) ccc_omm_is_empty(args)
#    define omm_size(args...) ccc_omm_size(args)
#    define omm_pop_max(args...) ccc_omm_pop_max(args)
#    define omm_pop_min(args...) ccc_omm_pop_min(args)
#    define omm_max(args...) ccc_omm_max(args)
#    define omm_min(args...) ccc_omm_min(args)
#    define omm_is_max(args...) ccc_omm_is_max(args)
#    define omm_is_min(args...) ccc_omm_is_min(args)
#    define omm_extract(args...) ccc_omm_extract(args)
#    define omm_update(args...) ccc_omm_update(args)
#    define omm_increase(args...) ccc_omm_increase(args)
#    define omm_decrease(args...) ccc_omm_decrease(args)
#    define omm_contains(args...) ccc_omm_contains(args)
#    define omm_begin(args...) ccc_omm_begin(args)
#    define omm_rbegin(args...) ccc_omm_rbegin(args)
#    define omm_next(args...) ccc_omm_next(args)
#    define omm_rnext(args...) ccc_omm_rnext(args)
#    define omm_end(args...) ccc_omm_end(args)
#    define omm_rend(args...) ccc_omm_rend(args)
#    define omm_equal_range(args...) ccc_omm_equal_range(args)
#    define omm_equal_rrange(args...) ccc_omm_equal_rrange(args)
#    define omm_validate(args...) ccc_omm_validate(args)
#endif /* ORDERED_MULTIMAP_USING_NAMESPACE_CCC */
 
#endif /* CCC_ORDERED_MULTIMAP_H */