LIST_DATA_TYPE

Table of Contents

LIST_DATA_TYPE

Description

Get data type stored by this list

Usage example (Cross-references)

    do {                                                                                                               \
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) * UNPL(_ptrval) = &(lval);                                                                   \
    LIST_DATA_TYPE(l) UNPL(_tmpval)   = *UNPL(_ptrval);                                                            \
    insert_into_list(GENERIC_LIST(l), UNPL(_ptrval), sizeof(LIST_DATA_TYPE(l)), (idx));                            \
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) * UNPL(_ptrval) = &(lval);                                                                   \
    LIST_DATA_TYPE(l) UNPL(_tmpval)   = *UNPL(_ptrval);                                                            \
    insert_into_list(GENERIC_LIST(l), UNPL(_ptrval), sizeof(LIST_DATA_TYPE(l)), (idx));                            \
    if (!(l)->copy_init) {                                                                                         \
    LIST_DATA_TYPE(l) * UNPL(_ptrval) = &(lval);                                                                   \
    LIST_DATA_TYPE(l) UNPL(_tmpval)   = *UNPL(_ptrval);                                                            \
    insert_into_list(GENERIC_LIST(l), UNPL(_ptrval), sizeof(LIST_DATA_TYPE(l)), (idx));                            \
    if (!(l)->copy_init) {                                                                                         \
    memset(UNPL(_ptrval), 0, sizeof(LIST_DATA_TYPE(l)));                                                       \
    insert_into_list(GENERIC_LIST(l), UNPL(_ptrval), sizeof(LIST_DATA_TYPE(l)), (idx));                            \
    if (!(l)->copy_init) {                                                                                         \
    memset(UNPL(_ptrval), 0, sizeof(LIST_DATA_TYPE(l)));                                                       \
    }                                                                                                              \
    } while (0)
    do {                                                                                                               \
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) UNPL(_rval) = (rval);                                                                        \
    insert_into_list(GENERIC_LIST(l), (char *)&UNPL(_rval), sizeof(LIST_DATA_TYPE(l)), (idx));                     \
    } while (0)
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) UNPL(_rval) = (rval);                                                                        \
    insert_into_list(GENERIC_LIST(l), (char *)&UNPL(_rval), sizeof(LIST_DATA_TYPE(l)), (idx));                     \
    } while (0)
    do {                                                                                                               \
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) * UNPL(_ptrval)     = (arr);                                                                 \
    const LIST_DATA_TYPE(l) UNPL(_tmpval) = *UNPL(_ptrval);                                                        \
    (void)UNPL(_tmpval);                                                                                           \
    ValidateList(l);                                                                                               \
    LIST_DATA_TYPE(l) * UNPL(_ptrval)     = (arr);                                                                 \
    const LIST_DATA_TYPE(l) UNPL(_tmpval) = *UNPL(_ptrval);                                                        \
    (void)UNPL(_tmpval);                                                                                           \
    push_arr_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), UNPL(_ptrval), (count));                             \
    const LIST_DATA_TYPE(l) UNPL(_tmpval) = *UNPL(_ptrval);                                                        \
    (void)UNPL(_tmpval);                                                                                           \
    push_arr_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), UNPL(_ptrval), (count));                             \
    if (!(l)->copy_init) {                                                                                         \
    memset(UNPL(_ptrval), 0, sizeof(LIST_DATA_TYPE(l)));                                                       \
    push_arr_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), UNPL(_ptrval), (count));                             \
    if (!(l)->copy_init) {                                                                                         \
    memset(UNPL(_ptrval), 0, sizeof(LIST_DATA_TYPE(l)));                                                       \
    }                                                                                                              \
    } while (0)
    ValidateList(l2);                                                                                              \
    {                                                                                                              \
    LIST_DATA_TYPE(l) UNPL(_tmp1)  = {0};                                                                      \
    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    {                                                                                                              \
    LIST_DATA_TYPE(l) UNPL(_tmp1)  = {0};                                                                      \
    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \
    merge_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), GENERIC_LIST(l2));                                      \
    if (!(l)->copy_init) {                                                                                         \
    GenericCopyDeinit cd = (l2)->copy_deinit;                                                                  \
    ValidateList(l2);                                                                                              \
    {                                                                                                              \
    LIST_DATA_TYPE(l) UNPL(_tmp1)  = {0};                                                                      \
    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    {                                                                                                              \
    LIST_DATA_TYPE(l) UNPL(_tmp1)  = {0};                                                                      \
    LIST_DATA_TYPE(l2) UNPL(_tmp2) = {0};                                                                      \
    UNPL(_tmp1)                    = UNPL(_tmp2);                                                              \
    (void)UNPL(_tmp1);                                                                                         \
    (void)UNPL(_tmp2);                                                                                         \
    }                                                                                                              \
    merge_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), GENERIC_LIST(l2));                                      \
    } while (0)
    /// FAILURE: NULL
    ///
    #define ListClear(l) clear_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)))
    
    ///
    /// FAILURE: Returns NULL otherwise.
    ///
    #define ListSort(l, compare) qsort_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (compare))
    
    ///
    /// FAILURE: NULL
    ///
    #define ListReverse(l) reverse_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)))
    
    #endif // MISRA_STD_CONTAINER_LIST_OPS_H
    ///
    #define ListRemove(l, val, idx)                                                                                        \
    remove_range_list(GENERIC_LIST(l), (val), sizeof(LIST_DATA_TYPE(l)), ((l)->length - 1), 1)
    
    ///
    ///
    #define ListRemoveRange(l, rd, start, count)                                                                           \
    remove_range_list(GENERIC_LIST(l), (rd), sizeof(LIST_DATA_TYPE(l)), (start), (count))
    
    ///
    /// Get node type stored by this list
    ///
    #define LIST_NODE_TYPE(list) ListNode(LIST_DATA_TYPE(list))
    
    ///
    #endif
    
    #define ListDeinit(v) deinit_list(GENERIC_LIST(v), sizeof(LIST_DATA_TYPE(v)))
    
    #endif // MISRA_STD_CONTAINER_LIST_H
    /// FAILURE: NULL
    ///
    #define ListSwapItems(l, idx1, idx2) swap_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx1), (idx2))
    
    ///
    /// FAILURE: `NULL`
    ///
    #define ListPtrAt(l, idx) ((LIST_DATA_TYPE(l) *)item_ptr_at_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx)))
    
    #ifdef __cplusplus
    
    #ifdef __cplusplus
    #    define ListAt(l, idx) (ListPtrAt((l), (idx)) ? *ListPtrAt((l), (idx)) : (LIST_DATA_TYPE(l) {0}))
    #else
    ///
    /// FAILURE: Emtpy object.
    ///
    #    define ListAt(l, idx) (ListPtrAt((l), (idx)) ? *ListPtrAt((l), (idx)) : ((LIST_DATA_TYPE(l)) {0}))
    #endif
    /// FAILURE: `NULL`
    ///
    #define ListNodePtrAt(l, idx) ((LIST_NODE_TYPE(l) *)(node_at_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx))))
    
    ///
    /// FAILURE: Empty node struct.
    ///
    #define ListNodeAt(l, idx) *((LIST_NODE_TYPE(l) *)(node_at_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx))))
    
    ///
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data)); \
    UNPL(_once);                                                                      \
    UNPL(_once) = false)
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data); \
    UNPL(_once);                                                                    \
    UNPL(_once) = false)
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                    \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                            \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data)); \
    UNPL(_once);                                                                      \
    UNPL(_once) = false)
    ((void *)UNPL(node)->prev != (void *)UNPL(node)) && (UNPL(node)->data))                  \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                          \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data); \
    UNPL(_once);                                                                    \
    UNPL(_once) = false)
    if (UNPL(i) >= (start) && (UNPL(node)->data))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data));     \
    UNPL(_once);                                                                          \
    UNPL(_once) = false)
    if (UNPL(i) >= (start) && (UNPL(node)->data))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data);       \
    UNPL(_once);                                                                          \
    UNPL(_once) = false)
    if (UNPL(i) >= (start) && (UNPL(node)->data))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data));     \
    UNPL(_once);                                                                          \
    UNPL(_once) = false)
    if (UNPL(i) >= (start) && (UNPL(node)->data))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = (LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(node)->data);       \
    UNPL(_once);                                                                          \
    UNPL(_once) = false)
    UNPL(pidx) = ++idx, UNPL(node) = UNPL(next))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                    \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(next)->data));         \
    UNPL(_once);                                                                              \
    UNPL(_once) = false)
    UNPL(pidx) = ++idx, UNPL(node) = UNPL(next))                                                      \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                    \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = UNPL(next)->data; UNPL(_once); UNPL(_once) = false)
    
    ///
    UNPL(node) = UNPL(next), UNPL(pidx) = idx)                                                        \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                    \
    for (LIST_DATA_TYPE(UNPL(pl)) var = *((LIST_DATA_TYPE(UNPL(pl)) *)(UNPL(next)->data));         \
    UNPL(_once);                                                                              \
    UNPL(_once) = false)                                                                      \
    UNPL(node) = UNPL(next), UNPL(pidx) = idx)                                                        \
    for (bool UNPL(_once) = true; UNPL(_once); UNPL(_once) = false)                                    \
    for (LIST_DATA_TYPE(UNPL(pl)) *var = UNPL(next)->data; UNPL(_once); UNPL(_once) = false)       \
    for (bool UNPL(_update)  = true; UNPL(_update);                                            \
    UNPL(_update)       = false,                                                          \

Share :