Skip to content

GENERIC_LIST

GENERIC_LIST

Description

Cast any list to a generic list

Usage example (Cross-references)

Usage examples (Cross-references)
                         (UNPL(next) =                                                                                     \
                              (UNPL(pidx) ? (GenericListNode *)get_node_random_access(                                     \
                                                GENERIC_LIST(UNPL(pl)),                                                    \
                                                GENERIC_LIST_NODE(UNPL(node)),                                             \
                                                UNPL(pidx),                                                                \
                         (UNPL(next) =                                                                                     \
                              (UNPL(pidx) ? (GenericListNode *)get_node_random_access(                                     \
                                                GENERIC_LIST(UNPL(pl)),                                                    \
                                                GENERIC_LIST_NODE(UNPL(node)),                                             \
                                                UNPL(pidx),                                                                \
                         (UNPL(next) =                                                                                     \
                              (UNPL(pidx) != idx ? (GenericListNode *)get_node_random_access(                              \
                                                       GENERIC_LIST(UNPL(pl)),                                             \
                                                       GENERIC_LIST_NODE(UNPL(node)),                                      \
                                                       UNPL(pidx),                                                         \
                         (UNPL(next) =                                                                                     \
                              (UNPL(pidx) != idx ? get_node_random_access(                                                 \
                                                       GENERIC_LIST(UNPL(pl)),                                             \
                                                       GENERIC_LIST_NODE(UNPL(node)),                                      \
                                                       UNPL(pidx),                                                         \
    ///
    #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
    /// 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))))
    
    ///
    /// FAILURE: `abort` with an error message.
    ///
    #define ValidateList(l) validate_list((const GenericList *)GENERIC_LIST(l))
    
    #endif // MISRA_STD_CONTAINER_LIST_TYPE_H
            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)));                                                       \
            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)
            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)));                                                       \
                (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;                                                                  \
                (void)UNPL(_tmp2);                                                                                         \
            }                                                                                                              \
            merge_list(GENERIC_LIST(l), sizeof(LIST_DATA_TYPE(l)), GENERIC_LIST(l2));                                      \
        } while (0)
Last updated on