Skip to content
LIST_DATA_TYPE

LIST_DATA_TYPE

LIST_DATA_TYPE

Description

Get data type stored by this list

Usage example (Cross-references)

Usage examples (Cross-references)
                        ((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,                                                          \
    ///
    #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))
    
    ///
    #endif
    
    #define ListDeinit(v) deinit_list(GENERIC_LIST(v), sizeof(LIST_DATA_TYPE(v)))
    
    #endif // MISRA_STD_CONTAINER_LIST_H
    /// 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
    /// 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))))
    
    ///
    /// Get node type stored by this list
    ///
    #define LIST_NODE_TYPE(list) ListNode(LIST_DATA_TYPE(list))
    
    ///
        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)
Last updated on