ordered_map.h

Go to the documentation of this file.

 
#ifndef CCC_ORDERED_MAP_H
#define CCC_ORDERED_MAP_H
 
#include <stdbool.h>
#include <stddef.h>
#include "impl/impl_ordered_map.h"
#include "types.h"
 
typedef union ccc_ordered_map_ ccc_ordered_map;
 
typedef union ccc_omap_elem_ ccc_omap_elem;
 
typedef union ccc_omap_entry_ ccc_omap_entry;
 
#define ccc_om_init(om_name, struct_name, om_elem_field, key_elem_field,       \
                    alloc_fn, key_cmp, aux)                                    \
    ccc_impl_om_init(om_name, struct_name, om_elem_field, key_elem_field,      \
                     alloc_fn, key_cmp, aux)
 
[[nodiscard]] bool ccc_om_contains(ccc_ordered_map *om, void const *key);
 
[[nodiscard]] void *ccc_om_get_key_val(ccc_ordered_map *om, void const *key);
 
[[nodiscard]] ccc_entry ccc_om_insert(ccc_ordered_map *om,
                                      ccc_omap_elem *key_val_handle,
                                      ccc_omap_elem *tmp);
 
#define ccc_om_insert_r(ordered_map_ptr, key_val_handle_ptr, tmp_ptr)          \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_om_insert((ordered_map_ptr), (key_val_handle_ptr), (tmp_ptr))      \
            .impl_                                                             \
    }
 
[[nodiscard]] ccc_entry ccc_om_try_insert(ccc_ordered_map *om,
                                          ccc_omap_elem *key_val_handle);
 
#define ccc_om_try_insert_r(ordered_map_ptr, key_val_handle_ptr)               \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_om_try_insert((ordered_map_ptr), (key_val_handle_ptr)).impl_       \
    }
 
#define ccc_om_try_insert_w(ordered_map_ptr, key, lazy_value...)               \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_impl_om_try_insert_w(ordered_map_ptr, key, lazy_value)             \
    }
 
[[nodiscard]] ccc_entry ccc_om_insert_or_assign(ccc_ordered_map *om,
                                                ccc_omap_elem *key_val_handle);
 
#define ccc_om_insert_or_assign_w(ordered_map_ptr, key, lazy_value...)         \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_impl_om_insert_or_assign_w(ordered_map_ptr, key, lazy_value)       \
    }
 
[[nodiscard]] ccc_entry ccc_om_remove(ccc_ordered_map *om,
                                      ccc_omap_elem *out_handle);
 
#define ccc_om_remove_r(ordered_map_ptr, out_handle_ptr)                       \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_om_remove((ordered_map_ptr), (out_handle_ptr)).impl_               \
    }
 
[[nodiscard]] ccc_omap_entry ccc_om_entry(ccc_ordered_map *om, void const *key);
 
#define ccc_om_entry_r(ordered_map_ptr, key_ptr)                               \
    &(ccc_omap_entry)                                                          \
    {                                                                          \
        ccc_om_entry((ordered_map_ptr), (key_ptr)).impl_                       \
    }
 
[[nodiscard]] ccc_omap_entry *ccc_om_and_modify(ccc_omap_entry *e,
                                                ccc_update_fn *fn);
 
[[nodiscard]] ccc_omap_entry *
ccc_om_and_modify_aux(ccc_omap_entry *e, ccc_update_fn *fn, void *aux);
 
#define ccc_om_and_modify_w(ordered_map_entry_ptr, type_name,                  \
                            closure_over_T...)                                 \
    &(ccc_omap_entry)                                                          \
    {                                                                          \
        ccc_impl_om_and_modify_w(ordered_map_entry_ptr, type_name,             \
                                 closure_over_T)                               \
    }
 
[[nodiscard]] void *ccc_om_or_insert(ccc_omap_entry const *e,
                                     ccc_omap_elem *elem);
 
#define ccc_om_or_insert_w(ordered_map_entry_ptr, lazy_key_value...)           \
    ccc_impl_om_or_insert_w(ordered_map_entry_ptr, lazy_key_value)
 
[[nodiscard]] void *ccc_om_insert_entry(ccc_omap_entry const *e,
                                        ccc_omap_elem *elem);
 
#define ccc_om_insert_entry_w(ordered_map_entry_ptr, lazy_key_value...)        \
    ccc_impl_om_insert_entry_w(ordered_map_entry_ptr, lazy_key_value)
 
[[nodiscard]] ccc_entry ccc_om_remove_entry(ccc_omap_entry *e);
 
#define ccc_om_remove_entry_r(ordered_map_entry_ptr)                           \
    &(ccc_entry)                                                               \
    {                                                                          \
        ccc_om_remove_entry((ordered_map_entry_ptr)).impl_                     \
    }
 
[[nodiscard]] void *ccc_om_unwrap(ccc_omap_entry const *e);
 
[[nodiscard]] bool ccc_om_occupied(ccc_omap_entry const *e);
 
[[nodiscard]] bool ccc_om_insert_error(ccc_omap_entry const *e);
 
[[nodiscard]] ccc_entry_status ccc_om_entry_status(ccc_omap_entry const *e);
 
[[nodiscard]] ccc_range ccc_om_equal_range(ccc_ordered_map *om,
                                           void const *begin_key,
                                           void const *end_key);
 
#define ccc_om_equal_range_r(ordered_map_ptr, begin_and_end_key_ptrs...)       \
    &(ccc_range)                                                               \
    {                                                                          \
        ccc_om_equal_range(ordered_map_ptr, begin_and_end_key_ptrs).impl_      \
    }
 
[[nodiscard]] ccc_rrange ccc_om_equal_rrange(ccc_ordered_map *om,
                                             void const *rbegin_key,
                                             void const *rend_key);
 
#define ccc_om_equal_rrange_r(ordered_map_ptr, rbegin_and_rend_key_ptrs...)    \
    &(ccc_rrange)                                                              \
    {                                                                          \
        ccc_om_equal_rrange(ordered_map_ptr, rbegin_and_rend_key_ptrs).impl_   \
    }
 
[[nodiscard]] void *ccc_om_begin(ccc_ordered_map const *om);
 
[[nodiscard]] void *ccc_om_rbegin(ccc_ordered_map const *om);
 
[[nodiscard]] void *ccc_om_next(ccc_ordered_map const *om,
                                ccc_omap_elem const *iter_handle);
 
[[nodiscard]] void *ccc_om_rnext(ccc_ordered_map const *om,
                                 ccc_omap_elem const *iter_handle);
 
[[nodiscard]] void *ccc_om_end(ccc_ordered_map const *om);
 
[[nodiscard]] void *ccc_om_rend(ccc_ordered_map const *om);
 
ccc_result ccc_om_clear(ccc_ordered_map *om, ccc_destructor_fn *destructor);
 
[[nodiscard]] bool ccc_om_is_empty(ccc_ordered_map const *om);
 
[[nodiscard]] size_t ccc_om_size(ccc_ordered_map const *om);
 
[[nodiscard]] bool ccc_om_validate(ccc_ordered_map const *om);
 
#ifdef ORDERED_MAP_USING_NAMESPACE_CCC
typedef ccc_omap_elem omap_elem;
typedef ccc_ordered_map ordered_map;
typedef ccc_omap_entry omap_entry;
#    define om_init(args...) ccc_om_init(args)
#    define om_and_modify_w(args...) ccc_om_and_modify_w(args)
#    define om_or_insert_w(args...) ccc_om_or_insert_w(args)
#    define om_insert_entry_w(args...) ccc_om_insert_entry_w(args)
#    define om_try_insert_w(args...) ccc_om_try_insert_w(args)
#    define om_insert_or_assign_w(args...) ccc_om_insert_or_assign_w(args)
#    define om_insert_r(args...) ccc_om_insert_r(args)
#    define om_remove_r(args...) ccc_om_remove_r(args)
#    define om_remove_entry_r(args...) ccc_om_remove_entry_r(args)
#    define om_entry_r(args...) ccc_om_entry_r(args)
#    define om_and_modify_r(args...) ccc_om_and_modify_r(args)
#    define om_and_modify_aux_r(args...) ccc_om_and_modify_aux_r(args)
#    define om_contains(args...) ccc_om_contains(args)
#    define om_get_key_val(args...) ccc_om_get_key_val(args)
#    define om_get_mut(args...) ccc_om_get_mut(args)
#    define om_insert(args...) ccc_om_insert(args)
#    define om_remove(args...) ccc_om_remove(args)
#    define om_entry(args...) ccc_om_entry(args)
#    define om_remove_entry(args...) ccc_om_remove_entry(args)
#    define om_or_insert(args...) ccc_om_or_insert(args)
#    define om_insert_entry(args...) ccc_om_insert_entry(args)
#    define om_unwrap(args...) ccc_om_unwrap(args)
#    define om_unwrap_mut(args...) ccc_om_unwrap_mut(args)
#    define om_begin(args...) ccc_om_begin(args)
#    define om_next(args...) ccc_om_next(args)
#    define om_rbegin(args...) ccc_om_rbegin(args)
#    define om_rnext(args...) ccc_om_rnext(args)
#    define om_end(args...) ccc_om_end(args)
#    define om_rend(args...) ccc_om_rend(args)
#    define om_size(args...) ccc_om_size(args)
#    define om_is_empty(args...) ccc_om_is_empty(args)
#    define om_clear(args...) ccc_om_clear(args)
#    define om_validate(args...) ccc_om_validate(args)
#endif
 
#endif /* CCC_ORDERED_MAP_H */