ucx: comparison src/cx/list.h

-:8ff82697f2c3
+:148b7c7ccaf9
 );
 /**
 * Member function for finding and optionally removing an element.
 */
-ssize_t (*find_remove)(
+size_t (*find_remove)(
 struct cx_list_s *list,
 const void *elem,
 bool remove
 );
 cx_attr_nonnull
 static inline int cxListAdd(
 CxList *list,
 const void *elem
 ) {
+list->collection.sorted = false;
 return list->cl->insert_element(list, list->collection.size, elem);
 }
 /**
 * Adds multiple items to the end of the list.
 static inline size_t cxListAddArray(
 CxList *list,
 const void *array,
 size_t n
 ) {
+list->collection.sorted = false;
 return list->cl->insert_array(list, list->collection.size, array, n);
 }
 /**
 * Inserts an item at the specified index.
 static inline int cxListInsert(
 CxList *list,
 size_t index,
 const void *elem
 ) {
+list->collection.sorted = false;
 return list->cl->insert_element(list, index, elem);
 }
 /**
 * Inserts an item into a sorted list.
+*
+* If the list is not sorted already, the behavior is undefined.
 *
 * @param list the list
 * @param elem a pointer to the element to add
 * @retval zero success
 * @retval non-zero memory allocation failure
 cx_attr_nonnull
 static inline int cxListInsertSorted(
 CxList *list,
 const void *elem
 ) {
+list->collection.sorted = true; // guaranteed by definition
 const void *data = list->collection.store_pointer ? &elem : elem;
 return list->cl->insert_sorted(list, data, 1) == 0;
 }
 /**
 CxList *list,
 size_t index,
 const void *array,
 size_t n
 ) {
+list->collection.sorted = false;
 return list->cl->insert_array(list, index, array, n);
 }
 /**
 * Inserts a sorted array into a sorted list.
 * If there is not enough memory to add all elements, the returned value is
 * less than @p n.
 *
 * If this list is storing pointers instead of objects @p array is expected to
 * be an array of pointers.
+*
+* If the list is not sorted already, the behavior is undefined.
 *
 * @param list the list
 * @param array a pointer to the elements to add
 * @param n the number of elements to add
 * @return the number of added elements
 static inline size_t cxListInsertSortedArray(
 CxList *list,
 const void *array,
 size_t n
 ) {
+list->collection.sorted = true; // guaranteed by definition
 return list->cl->insert_sorted(list, array, n);
 }
 /**
 * Inserts an element after the current location of the specified iterator.
 cx_attr_nonnull
 static inline int cxListInsertAfter(
 CxIterator *iter,
 const void *elem
 ) {
-return ((struct cx_list_s *) iter->src_handle.m)->cl->insert_iter(iter, elem, 0);
+CxList* list = iter->src_handle.m;
+list->collection.sorted = false;
+return list->cl->insert_iter(iter, elem, 0);
 }
 /**
 * Inserts an element before the current location of the specified iterator.
 *
 cx_attr_nonnull
 static inline int cxListInsertBefore(
 CxIterator *iter,
 const void *elem
 ) {
-return ((struct cx_list_s *) iter->src_handle.m)->cl->insert_iter(iter, elem, 1);
+CxList* list = iter->src_handle.m;
+list->collection.sorted = false;
+return list->cl->insert_iter(iter, elem, 1);
 }
 /**
 * Removes the element at the specified index.
 *
 *
 * @param list the list
 */
 cx_attr_nonnull
 static inline void cxListClear(CxList *list) {
+list->collection.sorted = true; // empty lists are always sorted
 list->cl->clear(list);
 }
 /**
 * Swaps two items in the list.
 static inline int cxListSwap(
 CxList *list,
 size_t i,
 size_t j
 ) {
+list->collection.sorted = false;
 return list->cl->swap(list, i, j);
 }
 /**
 * Returns a pointer to the element at the specified index.
 *
 * Determining equality is performed by the list's comparator function.
 *
 * @param list the list
 * @param elem the element to find
-* @return the index of the element or a negative
+* @return the index of the element or the size of the list when the element is not found
-* value when the element is not found
+* @see cxListIndexValid()
 */
 cx_attr_nonnull
 cx_attr_nodiscard
-static inline ssize_t cxListFind(
+static inline size_t cxListFind(
 const CxList *list,
 const void *elem
 ) {
 return list->cl->find_remove((CxList*)list, elem, false);
 }
 /**
+* Checks if the specified index is within bounds.
+*
+* @param list the list
+* @param index the index
+* @retval true if the index is within bounds
+* @retval false if the index is out of bounds
+*/
+cx_attr_nonnull
+cx_attr_nodiscard
+static inline bool cxListIndexValid(const CxList *list, size_t index) {
+return index < list->collection.size;
+}
+/**
 * Removes and returns the index of the first element that equals @p elem.
 *
 * Determining equality is performed by the list's comparator function.
 *
 * @param list the list
 * @param elem the element to find and remove
-* @return the index of the now removed element or a negative
+* @return the index of the now removed element or the list size
-* value when the element is not found or could not be removed
+* when the element is not found or could not be removed
-*/
+* @see cxListIndexValid()
-cx_attr_nonnull
+*/
-static inline ssize_t cxListFindRemove(
+cx_attr_nonnull
+static inline size_t cxListFindRemove(
 CxList *list,
 const void *elem
 ) {
 return list->cl->find_remove(list, elem, true);
 }
 * @param list the list
 */
 cx_attr_nonnull
 static inline void cxListSort(CxList *list) {
 list->cl->sort(list);
+list->collection.sorted = true;
 }
 /**
 * Reverses the order of the items.
 *
 * @param list the list
 */
 cx_attr_nonnull
 static inline void cxListReverse(CxList *list) {
+// still sorted, but not according to the cmp_func
+list->collection.sorted = false;
 list->cl->reverse(list);
 }
 /**
 * Compares a list to another list of the same type.

Mercurial > hg > ucx / file comparison

comparison: src/cx/list.h

src/cx/list.h