list.h

Go to the documentation of this file.

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef UCX_LIST_H
#define UCX_LIST_H
 
#include "common.h"
#include "collection.h"
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct cx_list_class_s cx_list_class;

struct cx_list_s {
    CX_COLLECTION_BASE;
    const cx_list_class *cl;
    const cx_list_class *climpl;
};

struct cx_list_class_s {
    void (*deallocate)(struct cx_list_s *list);

    void *(*insert_element)(struct cx_list_s *list, size_t index, const void *data);

    size_t (*insert_array)(struct cx_list_s *list, size_t index, const void *data, size_t n);

    size_t (*insert_sorted)(struct cx_list_s *list, const void *sorted_data, size_t n);

    size_t (*insert_unique)(struct cx_list_s *list, const void *sorted_data, size_t n);

    int (*insert_iter)(struct cx_iterator_s *iter, const void *elem, int prepend);

    size_t (*remove)(struct cx_list_s *list, size_t index, size_t num, void *targetbuf);

    void (*clear)(struct cx_list_s *list);

    int (*swap)(struct cx_list_s *list, size_t i, size_t j);

    void *(*at)(const struct cx_list_s *list, size_t index);

    size_t (*find_remove)(struct cx_list_s *list, const void *elem, bool remove);

    void (*sort)(struct cx_list_s *list);

    int (*compare)(const struct cx_list_s *list, const struct cx_list_s *other);

    void (*reverse)(struct cx_list_s *list);

    int (*change_capacity)(struct cx_list_s *list, size_t new_capacity);

    struct cx_iterator_s (*iterator)(const struct cx_list_s *list, size_t index, bool backward);
};

typedef struct cx_list_s CxList;

CX_EXPORT extern CxList *const cxEmptyList;

cx_attr_nonnull
CX_EXPORT size_t cx_list_default_insert_array(struct cx_list_s *list,
        size_t index, const void *data, size_t n);

cx_attr_nonnull
CX_EXPORT size_t cx_list_default_insert_sorted(struct cx_list_s *list,
        const void *sorted_data, size_t n);

cx_attr_nonnull
CX_EXPORT size_t cx_list_default_insert_unique(struct cx_list_s *list,
        const void *sorted_data, size_t n);

cx_attr_nonnull
CX_EXPORT void cx_list_default_sort(struct cx_list_s *list);

cx_attr_nonnull
CX_EXPORT int cx_list_default_swap(struct cx_list_s *list, size_t i, size_t j);

cx_attr_nonnull_arg(1, 2, 3)
CX_EXPORT void cx_list_init(struct cx_list_s *list,
    struct cx_list_class_s *cl, const struct cx_allocator_s *allocator,
    cx_compare_func comparator, size_t elem_size);

cx_attr_nonnull
CX_EXPORT size_t cxListSize(const CxList *list);

cx_attr_nonnull
CX_EXPORT int cxListAdd(CxList *list, const void *elem);

cx_attr_nonnull
CX_EXPORT size_t cxListAddArray(CxList *list, const void *array, size_t n);

cx_attr_nonnull
CX_EXPORT int cxListInsert(CxList *list, size_t index, const void *elem);

cx_attr_nonnull
CX_EXPORT void *cxListEmplaceAt(CxList *list, size_t index);

cx_attr_nonnull
CX_EXPORT void *cxListEmplace(CxList *list);

cx_attr_nonnull
CX_EXPORT CxIterator cxListEmplaceArrayAt(CxList *list, size_t index, size_t n);

cx_attr_nonnull
CX_EXPORT CxIterator cxListEmplaceArray(CxList *list, size_t n);

cx_attr_nonnull
CX_EXPORT int cxListInsertSorted(CxList *list, const void *elem);

cx_attr_nonnull
CX_EXPORT int cxListInsertUnique(CxList *list, const void *elem);

cx_attr_nonnull
CX_EXPORT size_t cxListInsertArray(CxList *list, size_t index, const void *array, size_t n);

cx_attr_nonnull
CX_EXPORT size_t cxListInsertSortedArray(CxList *list, const void *array, size_t n);

cx_attr_nonnull
CX_EXPORT size_t cxListInsertUniqueArray(CxList *list, const void *array, size_t n);

cx_attr_nonnull
CX_EXPORT int cxListInsertAfter(CxIterator *iter, const void *elem);

cx_attr_nonnull
CX_EXPORT int cxListInsertBefore(CxIterator *iter, const void *elem);

cx_attr_nonnull
CX_EXPORT int cxListRemove(CxList *list, size_t index);

cx_attr_nonnull cx_attr_access_w(3)
CX_EXPORT int cxListRemoveAndGet(CxList *list, size_t index, void *targetbuf);

cx_attr_nonnull cx_attr_access_w(2)
CX_EXPORT int cxListRemoveAndGetFirst(CxList *list, void *targetbuf);

#define cxListPopFront(list, targetbuf) cxListRemoveAndGetFirst((list), (targetbuf))
 

cx_attr_nonnull cx_attr_access_w(2)
CX_EXPORT int cxListRemoveAndGetLast(CxList *list, void *targetbuf);

#define cxListPop(list, targetbuf) cxListRemoveAndGetLast((list), (targetbuf))

cx_attr_nonnull
CX_EXPORT size_t cxListRemoveArray(CxList *list, size_t index, size_t num);

cx_attr_nonnull cx_attr_access_w(4)
CX_EXPORT size_t cxListRemoveArrayAndGet(CxList *list, size_t index, size_t num, void *targetbuf);

cx_attr_nonnull
CX_EXPORT void cxListClear(CxList *list);

cx_attr_nonnull
CX_EXPORT int cxListSwap(CxList *list, size_t i, size_t j);

cx_attr_nonnull
CX_EXPORT void *cxListAt(const CxList *list, size_t index);

cx_attr_nonnull
CX_EXPORT void *cxListFirst(const CxList *list);

cx_attr_nonnull
CX_EXPORT void *cxListLast(const CxList *list);

cx_attr_nonnull
CX_EXPORT int cxListSet(CxList *list, size_t index, const void *elem);

cx_attr_nodiscard
CX_EXPORT CxIterator cxListIteratorAt(const CxList *list, size_t index);

cx_attr_nodiscard
CX_EXPORT CxIterator cxListBackwardsIteratorAt(const CxList *list, size_t index);

cx_attr_nodiscard
CX_EXPORT CxIterator cxListIterator(const CxList *list);

cx_attr_nodiscard
CX_EXPORT CxIterator cxListBackwardsIterator(const CxList *list);

cx_attr_nonnull cx_attr_nodiscard
CX_EXPORT size_t cxListFind(const CxList *list, const void *elem);

cx_attr_nonnull cx_attr_nodiscard
CX_EXPORT bool cxListContains(const CxList* list, const void* elem);

cx_attr_nonnull cx_attr_nodiscard
CX_EXPORT bool cxListIndexValid(const CxList *list, size_t index);

cx_attr_nonnull
CX_EXPORT size_t cxListFindRemove(CxList *list, const void *elem);

cx_attr_nonnull
CX_EXPORT void cxListSort(CxList *list);

cx_attr_nonnull
CX_EXPORT void cxListReverse(CxList *list);

cx_attr_nonnull cx_attr_nodiscard
CX_EXPORT int cxListCompare(const CxList *list, const CxList *other);

CX_EXPORT void cxListFree(CxList *list);
 

cx_attr_nonnull_arg(1, 2, 3)
CX_EXPORT int cxListClone(CxList *dst, const CxList *src,
        cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);

cx_attr_nonnull_arg(1, 2, 3, 4)
CX_EXPORT int cxListDifference(CxList *dst,
        const CxList *minuend, const CxList *subtrahend,
        cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);

cx_attr_nonnull_arg(1, 2, 3, 4)
CX_EXPORT int cxListIntersection(CxList *dst, const CxList *src, const CxList *other,
        cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);

cx_attr_nonnull_arg(1, 2, 3, 4)
CX_EXPORT int cxListUnion(CxList *dst, const CxList *src, const CxList *other,
        cx_clone_func clone_func, const CxAllocator *clone_allocator, void *data);

cx_attr_nonnull
CX_EXPORT int cxListCloneSimple(CxList *dst, const CxList *src);

cx_attr_nonnull
CX_EXPORT int cxListDifferenceSimple(CxList *dst,
        const CxList *minuend, const CxList *subtrahend);

cx_attr_nonnull
CX_EXPORT int cxListIntersectionSimple(CxList *dst, const CxList *src, const CxList *other);

cx_attr_nonnull
CX_EXPORT int cxListUnionSimple(CxList *dst, const CxList *src, const CxList *other);

cx_attr_nonnull
CX_EXPORT int cxListReserve(CxList *list, size_t capacity);

cx_attr_nonnull
CX_EXPORT int cxListShrink(CxList *list);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // UCX_LIST_H