private_doubly_linked_list.h

 
#ifndef CCC_PRIVATE_DOUBLY_LINKED_LIST_H
#define CCC_PRIVATE_DOUBLY_LINKED_LIST_H
 
#include <stddef.h>
#include "../types.h" /* IWYU pragma: keep */
 
/* NOLINTBEGIN(readability-identifier-naming) */
 
struct CCC_Doubly_linked_list_node {
    struct CCC_Doubly_linked_list_node *next;
    struct CCC_Doubly_linked_list_node *previous;
};
 
struct CCC_Doubly_linked_list {
    struct CCC_Doubly_linked_list_node *head;
    struct CCC_Doubly_linked_list_node *tail;
    size_t sizeof_type;
    size_t type_intruder_offset;
};
 
/*=======================     Private Interface   ===========================*/
 
void CCC_private_doubly_linked_list_push_back(
    struct CCC_Doubly_linked_list *, struct CCC_Doubly_linked_list_node *
);
void CCC_private_doubly_linked_list_push_front(
    struct CCC_Doubly_linked_list *, struct CCC_Doubly_linked_list_node *
);
struct CCC_Doubly_linked_list_node *CCC_private_doubly_linked_list_node_in(
    struct CCC_Doubly_linked_list const *, void const *any_struct
);
 
/*=======================     Macro Implementations   =======================*/
 
#define CCC_private_doubly_linked_list_for(                                    \
    private_struct_name, private_type_intruder_field                           \
)                                                                              \
    (struct CCC_Doubly_linked_list) {                                          \
        .head = NULL, .tail = NULL,                                            \
        .sizeof_type = sizeof(private_struct_name),                            \
        .type_intruder_offset                                                  \
            = offsetof(private_struct_name, private_type_intruder_field),      \
    }
 
#define CCC_private_doubly_linked_list_from(                                   \
    private_type_intruder_field,                                               \
    private_allocator,                                                         \
    private_destructor,                                                        \
    private_compound_literal_array...                                          \
)                                                                              \
    (struct { struct CCC_Doubly_linked_list private; }){(__extension__({       \
        typeof(*private_compound_literal_array)                                \
            *private_doubly_linked_list_type_array                             \
            = private_compound_literal_array;                                  \
        struct CCC_Doubly_linked_list private_doubly_linked_list               \
            = CCC_private_doubly_linked_list_for(                              \
                typeof(*private_doubly_linked_list_type_array),                \
                private_type_intruder_field                                    \
            );                                                                 \
        CCC_Allocator const *const private_doubly_linked_list_allocator        \
            = &(private_allocator);                                            \
        if (private_doubly_linked_list_allocator->allocate) {                  \
            size_t const private_count                                         \
                = sizeof(private_compound_literal_array)                       \
                / sizeof(*private_doubly_linked_list_type_array);              \
            for (size_t private_i = 0; private_i < private_count;              \
                 ++private_i) {                                                \
                typeof(*private_doubly_linked_list_type_array) *const          \
                    private_new_node                                           \
                    = private_doubly_linked_list_allocator->allocate(          \
                        (CCC_Allocator_arguments){                             \
                            .input = NULL,                                     \
                            .bytes = private_doubly_linked_list.sizeof_type,   \
                            .context                                           \
                            = private_doubly_linked_list_allocator->context,   \
                        }                                                      \
                    );                                                         \
                if (!private_new_node) {                                       \
                    CCC_doubly_linked_list_clear(                              \
                        &private_doubly_linked_list,                           \
                        &private_destructor,                                   \
                        private_doubly_linked_list_allocator                   \
                    );                                                         \
                    break;                                                     \
                }                                                              \
                *private_new_node                                              \
                    = private_doubly_linked_list_type_array[private_i];        \
                CCC_private_doubly_linked_list_push_back(                      \
                    &private_doubly_linked_list,                               \
                    CCC_private_doubly_linked_list_node_in(                    \
                        &private_doubly_linked_list, private_new_node          \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_doubly_linked_list;                                            \
    }))}.private
 
#define CCC_private_doubly_linked_list_emplace_back(                           \
    doubly_linked_list_pointer,                                                \
    private_allocator_pointer,                                                 \
    struct_initializer...                                                      \
)                                                                              \
    (__extension__({                                                           \
        typeof(struct_initializer) *private_doubly_linked_list_res = NULL;     \
        struct CCC_Doubly_linked_list *private_doubly_linked_list              \
            = (doubly_linked_list_pointer);                                    \
        CCC_Allocator const *const private_doubly_linked_list_allocator        \
            = (private_allocator_pointer);                                     \
        if (private_doubly_linked_list && private_doubly_linked_list_allocator \
            && private_doubly_linked_list_allocator->allocate) {               \
            private_doubly_linked_list_res                                     \
                = private_doubly_linked_list_allocator->allocate((             \
                    CCC_Allocator_arguments                                    \
                ){                                                             \
                    .input = NULL,                                             \
                    .bytes = private_doubly_linked_list->sizeof_type,          \
                    .context = private_doubly_linked_list_allocator->context,  \
                });                                                            \
            if (private_doubly_linked_list_res) {                              \
                *private_doubly_linked_list_res = struct_initializer;          \
                CCC_private_doubly_linked_list_push_back(                      \
                    private_doubly_linked_list,                                \
                    CCC_private_doubly_linked_list_node_in(                    \
                        private_doubly_linked_list,                            \
                        private_doubly_linked_list_res                         \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_doubly_linked_list_res;                                        \
    }))
 
#define CCC_private_doubly_linked_list_emplace_front(                          \
    doubly_linked_list_pointer,                                                \
    private_allocator_pointer,                                                 \
    struct_initializer...                                                      \
)                                                                              \
    (__extension__({                                                           \
        typeof(struct_initializer) *private_doubly_linked_list_res = NULL;     \
        struct CCC_Doubly_linked_list *private_doubly_linked_list              \
            = (doubly_linked_list_pointer);                                    \
        CCC_Allocator const *const private_doubly_linked_list_allocator        \
            = (private_allocator_pointer);                                     \
        if (private_doubly_linked_list && private_doubly_linked_list_allocator \
            && private_doubly_linked_list_allocator->allocate) {               \
            private_doubly_linked_list_res                                     \
                = private_doubly_linked_list_allocator->allocate((             \
                    CCC_Allocator_arguments                                    \
                ){                                                             \
                    .input = NULL,                                             \
                    .bytes = private_doubly_linked_list->sizeof_type,          \
                    .context = private_doubly_linked_list_allocator->context,  \
                });                                                            \
            if (private_doubly_linked_list_res) {                              \
                *private_doubly_linked_list_res = struct_initializer;          \
                CCC_private_doubly_linked_list_push_front(                     \
                    private_doubly_linked_list,                                \
                    CCC_private_doubly_linked_list_node_in(                    \
                        private_doubly_linked_list,                            \
                        private_doubly_linked_list_res                         \
                    )                                                          \
                );                                                             \
            }                                                                  \
        }                                                                      \
        private_doubly_linked_list_res;                                        \
    }))
 
/* NOLINTEND(readability-identifier-naming) */
 
#endif /* CCC_PRIVATE_DOUBLY_LINKED_LIST_H */