types.h

Go to the documentation of this file.

 
#ifndef CCC_TYPES_H
#define CCC_TYPES_H
 
#include <stddef.h>
#include <stdint.h>
typedef struct {
    void *begin;
    void *end;
} CCC_Range;
 
typedef struct {
    void *reverse_begin;
    void *reverse_end;
} CCC_Range_reverse;
 
typedef size_t CCC_Handle_index;
 
typedef struct {
    CCC_Handle_index begin;
    CCC_Handle_index end;
} CCC_Handle_range;
 
typedef struct {
    CCC_Handle_index reverse_begin;
    CCC_Handle_index reverse_end;
} CCC_Handle_range_reverse;
 
typedef enum : uint8_t {
    CCC_ENTRY_VACANT = 0,
    CCC_ENTRY_OCCUPIED = 0x1,
    CCC_ENTRY_INSERT_ERROR = 0x2,
    CCC_ENTRY_ARGUMENT_ERROR = 0x4,
    CCC_ENTRY_NO_UNWRAP = 0x8,
} CCC_Entry_status;
 
typedef struct {
    void *type;
    CCC_Entry_status status;
} CCC_Entry;
 
typedef struct {
    CCC_Handle_index index;
    CCC_Entry_status status;
} CCC_Handle;
 
typedef CCC_Entry_status CCC_Handle_status;
 
typedef enum : int8_t {
    CCC_TRIBOOL_ERROR = -1,
    CCC_FALSE,
    CCC_TRUE,
} CCC_Tribool;
 
typedef enum : uint8_t {
    CCC_RESULT_OK = 0,
    CCC_RESULT_FAIL,
    CCC_RESULT_NO_ALLOCATION_FUNCTION,
    CCC_RESULT_ALLOCATOR_ERROR,
    CCC_RESULT_ARGUMENT_ERROR,
    CCC_PRIVATE_RESULT_COUNT,
} CCC_Result;
 
typedef enum : int8_t {
    CCC_ORDER_LESSER = -1,
    CCC_ORDER_EQUAL,
    CCC_ORDER_GREATER,
    CCC_ORDER_ERROR,
} CCC_Order;
 
typedef struct {
    CCC_Result error;
    size_t count;
} CCC_Count;
 
typedef struct {
    void *const type;
    void *const context;
} CCC_Arguments;
 
typedef struct {
    void *const input;
    size_t bytes;
    void *const context;
} CCC_Allocator_arguments;
 
typedef void *CCC_Allocator_interface(CCC_Allocator_arguments);
 
typedef struct {
    CCC_Allocator_interface *allocate;
    void *context;
} CCC_Allocator;
 
typedef struct {
    void const *const type_left;
    void const *const type_right;
    void *const context;
} CCC_Comparator_arguments;
 
typedef CCC_Order CCC_Comparator_interface(CCC_Comparator_arguments);
 
typedef struct {
    CCC_Comparator_interface *compare;
    void *context;
} CCC_Comparator;
 
typedef void CCC_Modifier_interface(CCC_Arguments);
 
typedef struct {
    CCC_Modifier_interface *modify;
    void *context;
} CCC_Modifier;
 
typedef void CCC_Destructor_interface(CCC_Arguments);
 
typedef struct {
    CCC_Destructor_interface *destroy;
    void *context;
} CCC_Destructor;
 
typedef struct {
    void const *const key_left;
    void const *const type_right;
    void *const context;
} CCC_Key_comparator_arguments;
 
typedef CCC_Order CCC_Key_comparator_interface(CCC_Key_comparator_arguments);
 
typedef struct {
    CCC_Key_comparator_interface *compare;
    void *context;
} CCC_Key_comparator;
 
typedef struct {
    void const *const key;
    void *const context;
} CCC_Key_arguments;
 
typedef uint64_t CCC_Key_hasher_interface(CCC_Key_arguments);
 
typedef struct {
    CCC_Key_hasher_interface *hash;
    CCC_Key_comparator_interface *compare;
    void *context;
} CCC_Hasher;
 
CCC_Tribool CCC_entry_occupied(CCC_Entry const *entry);
 
CCC_Tribool CCC_entry_insert_error(CCC_Entry const *entry);
 
CCC_Tribool CCC_entry_argument_error(CCC_Entry const *entry);
 
void *CCC_entry_unwrap(CCC_Entry const *entry);
 
CCC_Tribool CCC_handle_occupied(CCC_Handle const *handle);
 
CCC_Tribool CCC_handle_insert_error(CCC_Handle const *handle);
 
CCC_Tribool CCC_handle_argument_error(CCC_Handle const *handle);
 
CCC_Handle_index CCC_handle_unwrap(CCC_Handle const *handle);
 
void *CCC_range_begin(CCC_Range const *range);
 
void *CCC_range_end(CCC_Range const *range);
 
void *CCC_range_reverse_begin(CCC_Range_reverse const *range);
 
void *CCC_range_reverse_end(CCC_Range_reverse const *range);
 
CCC_Handle_index CCC_handle_range_begin(CCC_Handle_range const *range);
 
CCC_Handle_index CCC_handle_range_end(CCC_Handle_range const *range);
 
CCC_Handle_index
CCC_handle_range_reverse_begin(CCC_Handle_range_reverse const *range);
 
CCC_Handle_index
CCC_handle_range_reverse_end(CCC_Handle_range_reverse const *range);
 
char const *CCC_result_message(CCC_Result result);
 
CCC_Entry_status CCC_entry_status(CCC_Entry const *entry);
 
CCC_Handle_status CCC_handle_status(CCC_Handle const *handle);
 
char const *CCC_entry_status_message(CCC_Entry_status status);
 
char const *CCC_handle_status_message(CCC_Handle_status status);
 
#ifdef TYPES_USING_NAMESPACE_CCC
/* NOLINTBEGIN(readability-identifier-naming) */
typedef CCC_Range Range;
typedef CCC_Range_reverse Range_reverse;
typedef CCC_Handle_range Handle_range;
typedef CCC_Handle_range_reverse Handle_range_reverse;
typedef CCC_Entry Entry;
typedef CCC_Handle Handle;
typedef CCC_Handle_index Handle_index;
typedef CCC_Result Result;
typedef CCC_Order Order;
typedef CCC_Arguments Arguments;
typedef CCC_Comparator_arguments Comparator_arguments;
typedef CCC_Key_arguments Key_arguments;
typedef CCC_Key_comparator_arguments Key_comparator_arguments;
typedef CCC_Allocator_interface Allocator_interface;
typedef CCC_Comparator_interface Comparator_interface;
typedef CCC_Modifier_interface Modifier_interface;
typedef CCC_Destructor_interface Destructor_interface;
typedef CCC_Key_comparator_interface Key_comparator_interface;
typedef CCC_Key_hasher_interface Key_hasher_interface;
#    define entry_occupied(entry_pointer) CCC_entry_occupied(entry_pointer)
#    define entry_insert_error(entry_pointer)                                  \
        CCC_entry_insert_error(entry_pointer)
#    define entry_argument_error(entry_pointer)                                \
        CCC_entry_argument_error(entry_pointer)
#    define handle_argument_error(handle_pointer)                              \
        CCC_handle_argument_error(handle_pointer)
#    define entry_unwrap(entry_pointer) CCC_entry_unwrap(entry_pointer)
#    define entry_status(entry_pointer) CCC_entry_status(entry_pointer)
#    define entry_status_message(status) CCC_entry_status_message(status)
#    define handle_occupied(array_pointer) CCC_handle_occupied(array_pointer)
#    define handle_insert_error(array_pointer)                                 \
        CCC_handle_insert_error(array_pointer)
#    define handle_unwrap(array_pointer) CCC_handle_unwrap(array_pointer)
#    define handle_status(array_pointer) CCC_handle_status(array_pointer)
#    define handle_status_message(status) CCC_handle_status_message(status)
#    ifndef range_begin
#        define range_begin(range_pointer) CCC_range_begin(range_pointer)
#    endif
#    ifndef range_end
#        define range_end(range_pointer) CCC_range_end(range_pointer)
#    endif
#    ifndef range_reverse_begin
#        define range_reverse_begin(range_pointer)                             \
            CCC_range_reverse_begin(range_pointer)
#    endif
#    ifndef range_reverse_end
#        define range_reverse_end(range_pointer)                               \
            CCC_range_reverse_end(range_pointer)
#    endif
#    define handle_range_begin(handle_range_pointer)                           \
        CCC_handle_range_begin(handle_range_pointer)
#    define handle_range_end(handle_range_pointer)                             \
        CCC_handle_range_end(handle_range_pointer)
#    define handle_range_reverse_begin(handle_range_pointer)                   \
        CCC_handle_range_reverse_begin(handle_range_pointer)
#    define handle_range_reverse_end(handle_range_pointer)                     \
        CCC_handle_range_reverse_end(handle_range_pointer)
#    define result_message(res) CCC_result_message(res)
/* NOLINTEND(readability-identifier-naming) */
#endif /* TYPES_USING_NAMESPACE_CCC */
 
#endif /* CCC_TYPES_H */