ucx: comparison src/cx/list.h

-:3dc9075df822
+:eb9e7bd40a8e
 void const *left,
 void const *right
 );
 /**
-* Internal type for the list structure - use CxList instead.
+* List class type.
 */
-typedef struct cx_list_s cx_list_s;
+typedef struct cx_list_class_s cx_list_class;
+/**
+* Structure for holding the base data of a list.
+*/
+struct cx_list_s {
+/**
+* The list class definition.
+*/
+cx_list_class *cl;
+/**
+* The allocator to use.
+*/
+CxAllocator *allocator;
+/**
+* The comparator function for the elements.
+*/
+CxListComparator cmpfunc;
+/**
+* The size of each element (payload only).
+*/
+size_t itemsize;
+/**
+* The size of the list (number of currently stored elements).
+*/
+size_t size;
+/**
+* The capacity of the list (maximum number of elements).
+*/
+size_t capacity;
+};
 /**
 * The class definition for arbitrary lists.
 */
-typedef struct {
+struct cx_list_class_s {
 /**
 * Member function for adding an element.
 */
 int (*add)(
-cx_list_s *list,
+struct cx_list_s *list,
 void const *elem
 );
 /**
 * Member function for inserting an element.
 */
 int (*insert)(
-cx_list_s *list,
+struct cx_list_s *list,
 size_t index,
 void const *elem
 );
 /**
 * Member function for inserting an element relative to an iterator position.
 */
 int (*insert_iter)(
-CxIterator *iter,
+struct cx_iterator_s *iter,
 void const *elem,
 int prepend
 );
 /**
 * Member function for removing an element.
 */
 int (*remove)(
-cx_list_s *list,
+struct cx_list_s *list,
 size_t index
 );
 /**
 * Member function for element lookup.
 */
 void *(*at)(
-cx_list_s const *list,
+struct cx_list_s const *list,
 size_t index
 );
 /**
 * Member function for finding an element.
 */
 size_t (*find)(
-cx_list_s const *list,
+struct cx_list_s const *list,
 void const *elem
 );
 /**
 * Member function for sorting the list in place.
 */
-void (*sort)(cx_list_s *list);
+void (*sort)(struct cx_list_s *list);
 /**
 * Member function for comparing this list to another list of the same type.
 */
 int (*compare)(
-cx_list_s const *list,
+struct cx_list_s const *list,
-cx_list_s const *other
+struct cx_list_s const *other
 );
 /**
 * Member function for reversing the order of the items.
 */
-void (*reverse)(cx_list_s *list);
+void (*reverse)(struct cx_list_s *list);
 /**
 * Returns an iterator pointing to the specified index.
 */
-CxIterator (*iterator)(
+struct cx_iterator_s (*iterator)(
-cx_list_s *list,
+struct cx_list_s *list,
 size_t index
 );
-} cx_list_class;
-/**
-* Structure for holding the base data of a list.
-*/
-struct cx_list_s {
-/**
-* The list class definition.
-*/
-cx_list_class *cl;
-/**
-* The allocator to use.
-*/
-CxAllocator allocator;
-/**
-* The comparator function for the elements.
-*/
-CxListComparator cmpfunc;
-/**
-* The size of each element (payload only).
-*/
-size_t itemsize;
-/**
-* The size of the list (number of currently stored elements).
-*/
-size_t size;
-/**
-* The capacity of the list (maximum number of elements).
-*/
-size_t capacity;
 };
 /**
 * Common type for all list implementations.
 */
-typedef cx_list_s *CxList;
+typedef struct cx_list_s CxList;
 /**
 * Adds an item to the end of the list.
 *
 * @param list the list
 * @param elem a pointer to the element to add
 * @return zero on success, non-zero on memory allocation failure
 */
 static inline int cxListAdd(
-CxList list,
+CxList *list,
 void const *elem
 ) {
 return list->cl->add(list, elem);
 }
 * or when the index is out of bounds
 * @see cxListInsertAfter()
 * @see cxListInsertBefore()
 */
 static inline int cxListInsert(
-CxList list,
+CxList *list,
 size_t index,
 void const *elem
 ) {
 return list->cl->insert(list, index, elem);
 }
 */
 static inline int cxListInsertAfter(
 CxIterator *iter,
 void const *elem
 ) {
-return ((cx_list_s *) iter->src_handle)->cl->insert_iter(iter, elem, 0);
+return ((struct cx_list_s *) iter->src_handle)->cl->insert_iter(iter, elem, 0);
 }
 /**
 * Inserts an element before the current location of the specified iterator.
 *
 */
 static inline int cxListInsertBefore(
 CxIterator *iter,
 void const *elem
 ) {
-return ((cx_list_s *) iter->src_handle)->cl->insert_iter(iter, elem, 1);
+return ((struct cx_list_s *) iter->src_handle)->cl->insert_iter(iter, elem, 1);
 }
 /**
 * Removes the element at the specified index.
 * @param list the list
 * @param index the index of the element
 * @return zero on success, non-zero if the index is out of bounds
 */
 static inline int cxListRemove(
-CxList list,
+CxList *list,
 size_t index
 ) {
 return list->cl->remove(list, index);
 }
 * @param list the list
 * @param index the index of the element
 * @return a pointer to the element or \c NULL if the index is out of bounds
 */
 static inline void *cxListAt(
-CxList list,
+CxList *list,
 size_t index
 ) {
 return list->cl->at(list, index);
 }
 * @param list the list
 * @param index the index where the iterator shall point at
 * @return a new iterator
 */
 static inline CxIterator cxListIterator(
-CxList list,
+CxList *list,
 size_t index
 ) {
 return list->cl->iterator(list, index);
 }
 * If the list is empty, a past-the-end iterator will be returned.
 *
 * @param list the list
 * @return a new iterator
 */
-static inline CxIterator cxListBegin(CxList list) {
+static inline CxIterator cxListBegin(CxList *list) {
 return list->cl->iterator(list, 0);
 }
 /**
 * Returns the index of the first element that equals \p elem.
 * @param list the list
 * @param elem the element to find
 * @return the index of the element or \c (size+1) if the element is not found
 */
 static inline size_t cxListFind(
-CxList list,
+CxList *list,
 void const *elem
 ) {
 return list->cl->find(list, elem);
 }
 *
 * \remark The underlying sort algorithm is implementation defined.
 *
 * @param list the list
 */
-static inline void cxListSort(CxList list) {
+static inline void cxListSort(CxList *list) {
 list->cl->sort(list);
 }
 /**
 * Reverses the order of the items.
 *
 * @param list the list
 */
-static inline void cxListReverse(CxList list) {
+static inline void cxListReverse(CxList *list) {
 list->cl->reverse(list);
 }
 /**
 * Compares a list to another list of the same type.
 * @param list the list
 * @param other the list to compare to
 * @return zero, if both lists are equal element wise, negative if the first list is smaller, zero if the first list is larger
 */
 static inline int cxListCompare(
-CxList list,
+CxList *list,
-CxList other
+CxList *other
 ) {
 return list->cl->compare(list, other);
 }
 #ifdef __cplusplus

Mercurial > hg > ucx / file comparison

comparison: src/cx/list.h

src/cx/list.h