private_singly_linked_list.h

Go to the documentation of this file.

 
#ifndef CCC_PRIVATE_SINGLY_LINKED_LIST_H
#define CCC_PRIVATE_SINGLY_LINKED_LIST_H
 
#include <stddef.h>
#include "../types.h" /* IWYU pragma: keep */
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Singly_linked_list_node {
    struct CCC_Singly_linked_list_node *next;
};
 
struct CCC_Singly_linked_list {
    struct CCC_Singly_linked_list_node *head;
    size_t sizeof_type;
    size_t alignof_type;
    size_t type_intruder_offset;
};
 
/*=========================   Private Interface  ============================*/
 
void CCC_private_singly_linked_list_push_front(
    struct CCC_Singly_linked_list *, struct CCC_Singly_linked_list_node *
);
struct CCC_Singly_linked_list_node *CCC_private_singly_linked_list_node_in(
    struct CCC_Singly_linked_list const *, void const *
);
 
/*======================   Macro Implementations     ========================*/
 
#define CCC_private_singly_linked_list_for(                                    \
    private_struct_name, private_singly_linked_list_node_field                 \
)                                                                              \
    (struct CCC_Singly_linked_list) {                                          \
        .head = NULL, .sizeof_type = sizeof(private_struct_name),              \
        .alignof_type = alignof(private_struct_name),                          \
        .type_intruder_offset = offsetof(                                      \
            private_struct_name, private_singly_linked_list_node_field         \
        ),                                                                     \
    }
 
#define CCC_private_singly_linked_list_default(                                \
    private_struct_name, private_singly_linked_list_node_field                 \
)                                                                              \
    CCC_private_singly_linked_list_for(                                        \
        private_struct_name, private_singly_linked_list_node_field             \
    )
 
#define CCC_private_singly_linked_list_from(                                   \
    private_type_intruder_field,                                               \
    private_allocator,                                                         \
    private_destructor,                                                        \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Singly_linked_list private; }){(__extension__({       \
        typeof(*private_compound_literal_array)                                \
            *private_singly_linked_list_type_array                             \
            = private_compound_literal_array;                                  \
        struct CCC_Singly_linked_list private_singly_linked_list               \
            = CCC_private_singly_linked_list_for(                              \
                typeof(*private_singly_linked_list_type_array),                \
                private_type_intruder_field                                    \
            );                                                                 \
        CCC_Allocator const *const private_singly_linked_list_allocator        \
            = &(private_allocator);                                            \
        if (private_singly_linked_list_allocator->allocate) {                  \
            size_t private_count                                               \
                = sizeof(private_compound_literal_array)                       \
                / sizeof(*private_singly_linked_list_type_array);              \
            while (private_count--) {                                          \
                typeof(*private_singly_linked_list_type_array) *const          \
                    private_new_node                                           \
                    = private_singly_linked_list_allocator->allocate(          \
                        (CCC_Allocator_arguments){                             \
                            .input = NULL,                                     \
                            .bytes = private_singly_linked_list.sizeof_type,   \
                            .context                                           \
                            = private_singly_linked_list_allocator->context,   \
                        }                                                      \
                    );                                                         \
                if (!private_new_node) {                                       \
                    CCC_singly_linked_list_clear(                              \
                        &private_singly_linked_list,                           \
                        &private_destructor,                                   \
                        private_singly_linked_list_allocator                   \
                    );                                                         \
                    break;                                                     \
                }                                                              \
                *private_new_node                                              \
                    = private_singly_linked_list_type_array[private_count];    \
                CCC_private_singly_linked_list_push_front(                     \
                    &private_singly_linked_list,                               \
                    CCC_private_singly_linked_list_node_in(                    \
                        &private_singly_linked_list, private_new_node          \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_singly_linked_list;                                            \
    }))}.private
 
#define CCC_private_singly_linked_list_emplace_front(                          \
    list_pointer, private_allocator_pointer, struct_initializer...             \
)                                                                              \
    (__extension__({                                                           \
        typeof(struct_initializer) *private_singly_linked_list_res = NULL;     \
        struct CCC_Singly_linked_list *private_singly_linked_list              \
            = (list_pointer);                                                  \
        CCC_Allocator const *const private_singly_linked_list_allocator        \
            = (private_allocator_pointer);                                     \
        if (private_singly_linked_list && private_singly_linked_list_allocator \
            && private_singly_linked_list_allocator->allocate) {               \
            private_singly_linked_list_res                                     \
                = private_singly_linked_list->allocate(                        \
                    (CCC_Allocator_arguments){                                 \
                        .input = NULL,                                         \
                        .bytes = private_singly_linked_list->sizeof_type,      \
                        .context = private_singly_linked_list->context,        \
                    }                                                          \
                );                                                             \
            if (private_singly_linked_list_res) {                              \
                *private_singly_linked_list_res = struct_initializer;          \
                CCC_private_singly_linked_list_push_front(                     \
                    private_singly_linked_list,                                \
                    CCC_private_singly_linked_list_node_in(                    \
                        private_singly_linked_list,                            \
                        private_singly_linked_list_res                         \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_singly_linked_list_res;                                        \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_SINGLY_LINKED_LIST_H */