Skip to content
LIST_DATA_TYPE

LIST_DATA_TYPE

Description

Get data type stored by this list

Usage example (Cross-references)

Usage examples (Cross-references)
    /// TAGS: List, Deinit, Lifecycle
    ///
    #define ListDeinit(v) deinit_list(GENERIC_LIST(v), sizeof(LIST_DATA_TYPE(v)))
    
    #endif // MISRA_STD_CONTAINER_LIST_INIT_H
    /// TAGS: List, Ops, Clear
    ///
    #define ListClear(l) clear_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)))
    
    ///
    /// TAGS: List, Ops, Sort
    ///
    #define ListSort(l, compare) list_sort(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (compare))
    
    ///
    /// TAGS: List, Ops, Reverse
    ///
    #define ListReverse(l) reverse_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)))
    
    #endif // MISRA_STD_CONTAINER_LIST_OPS_H
    /// TAGS: List, Access, Swap
    ///
    #define ListSwapItems(l, idx1, idx2) swap_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx1), (idx2))
    
    ///
    /// TAGS: List, Access, API
    ///
    #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
    ///
    /// TAGS: List, Access, API
    ///
    #    define ListAt(l, idx) (ListPtrAt((l), (idx)) ? *ListPtrAt((l), (idx)) : ((LIST_DATA_TYPE(l)) {0}))
    #endif
    /// TAGS: List, Find, Search, Compare
    ///
    #define ListFind(l, item_ptr, compare) find_idx_list(GENERIC_LIST(l), (item_ptr), sizeof(LIST_DATA_TYPE(l)), (compare))
    
    ///
    /// TAGS: List, Node, Access
    ///
    #define ListNodePtrAt(l, idx) ((LIST_NODE_TYPE(l) *)(node_at_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx))))
    
    ///
    /// TAGS: List, Node, Access
    ///
    #define ListNodeAt(l, idx) (*((LIST_NODE_TYPE(l) *)(node_at_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), (idx)))))
    
    ///
    /// TAGS: List, Remove
    ///
    #define ListRemove(l, val, idx) remove_range_list(GENERIC_LIST(l), (val), sizeof(LIST_DATA_TYPE(l)), (idx), 1)
    
    ///
    ///
    #define ListRemoveRange(l, rd, start, count)                                                                           \
        remove_range_list(GENERIC_LIST(l), (rd), sizeof(LIST_DATA_TYPE(l)), (start), (count))
    
    ///
                        ((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(resolved_idx) = idx), 1) && 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(resolved_idx) = idx), 1) && 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(resolved_idx) = idx), 1) && 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(resolved_idx) = idx), 1) && 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)
    #define ListInsertL(l, lval, idx)                                                                                      \
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_EQUIVALENCE(TYPE_OF(lval), LIST_DATA_TYPE(l)),                                                         \
         list_insert_one_l(GENERIC_LIST(l), &LVAL_AS(LIST_DATA_TYPE(l), lval), &(lval), sizeof(LIST_DATA_TYPE(l)), (idx)))
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_EQUIVALENCE(TYPE_OF(lval), LIST_DATA_TYPE(l)),                                                         \
         list_insert_one_l(GENERIC_LIST(l), &LVAL_AS(LIST_DATA_TYPE(l), lval), &(lval), sizeof(LIST_DATA_TYPE(l)), (idx)))
    
    ///
    #define ListInsertR(l, rval, idx)                                                                                      \
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_CONVERTIBLE(LIST_DATA_TYPE(l), rval),                                                                  \
         list_insert_one_r(GENERIC_LIST(l), &LVAL_AS(LIST_DATA_TYPE(l), rval), sizeof(LIST_DATA_TYPE(l)), (idx)))
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_CONVERTIBLE(LIST_DATA_TYPE(l), rval),                                                                  \
         list_insert_one_r(GENERIC_LIST(l), &LVAL_AS(LIST_DATA_TYPE(l), rval), sizeof(LIST_DATA_TYPE(l)), (idx)))
    
    ///
    #define ListPushArrL(l, arr, count)                                                                                    \
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_EQUIVALENCE(TYPE_OF(*(arr)), LIST_DATA_TYPE(l)),                                                       \
         list_insert_range_l(GENERIC_LIST(l), (void *)(arr), sizeof(LIST_DATA_TYPE(l)), (count)))
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_EQUIVALENCE(TYPE_OF(*(arr)), LIST_DATA_TYPE(l)),                                                       \
         list_insert_range_l(GENERIC_LIST(l), (void *)(arr), sizeof(LIST_DATA_TYPE(l)), (count)))
    
    ///
    #define ListPushArrR(l, arr, count)                                                                                    \
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_CONVERTIBLE(const LIST_DATA_TYPE(l) *, arr),                                                           \
         list_insert_range_r(GENERIC_LIST(l), (const void *)(arr), sizeof(LIST_DATA_TYPE(l)), (count)))
        (ValidateList(l),                                                                                                  \
         CHECK_TYPE_CONVERTIBLE(const LIST_DATA_TYPE(l) *, arr),                                                           \
         list_insert_range_r(GENERIC_LIST(l), (const void *)(arr), sizeof(LIST_DATA_TYPE(l)), (count)))
    
    ///
        (ValidateList(l),                                                                                                  \
         ValidateList(l2),                                                                                                 \
         CHECK_TYPE_EQUIVALENCE(LIST_DATA_TYPE(l2), LIST_DATA_TYPE(l)),                                                    \
         list_merge_l(GENERIC_LIST(l), GENERIC_LIST(l2), sizeof(LIST_DATA_TYPE(l))))
         ValidateList(l2),                                                                                                 \
         CHECK_TYPE_EQUIVALENCE(LIST_DATA_TYPE(l2), LIST_DATA_TYPE(l)),                                                    \
         list_merge_l(GENERIC_LIST(l), GENERIC_LIST(l2), sizeof(LIST_DATA_TYPE(l))))
    
    ///
        (ValidateList(l),                                                                                                  \
         ValidateList(l2),                                                                                                 \
         CHECK_TYPE_EQUIVALENCE(LIST_DATA_TYPE(l2), LIST_DATA_TYPE(l)),                                                    \
         list_merge_r(GENERIC_LIST(l), GENERIC_LIST(l2), sizeof(LIST_DATA_TYPE(l))))
         ValidateList(l2),                                                                                                 \
         CHECK_TYPE_EQUIVALENCE(LIST_DATA_TYPE(l2), LIST_DATA_TYPE(l)),                                                    \
         list_merge_r(GENERIC_LIST(l), GENERIC_LIST(l2), sizeof(LIST_DATA_TYPE(l))))
    
    ///
    /// TAGS: List, Type, TypeOf
    ///
    #define LIST_NODE_TYPE(list) ListNode(LIST_DATA_TYPE(list))
    
    ///
Last updated on