ucx: comparison docs/Writerside/topics/list.h.md

-:e46406fd1b3c
+:c6f55a2b3495
 return 0;
 }
 }
 ```
-Also, just registering `regfree()` as destructor is not enough anymore, because the `regex_t` structure also needs to be freed.
+Also, just registering `regfree()` as a destructor is not enough anymore because the `regex_t` structure also needs to be freed.
 Therefore, we would need to wrap the calls to `regfree()` and `free()` into an own destructor, which we then register with the list.
 However, it should be clear by now that using `CX_STORE_POINTERS` is a bad choice for this use case to begin with.
 As a rule of thumb: if you allocate memory for an element that you immediately put into the list, consider storing the element directly.
 And if you are getting pointers to already allocated memory from somewhere else, and you just want to organize those elements in a list, then consider using `CX_STORE_POINTERS`.
 This function replaces the element at the specified `index` with the value pointed to by `elem`.
 If the list is storing values directly (not pointers), the contents at the memory location `elem` will be copied into the list.
 If the list is storing pointers, the pointer value itself will be stored.
 The function returns `0` on success and `1` if the index is out of bounds.
-On the other hand, `cxListFind()` searches for the element pointed to by `elem` by comparing each element in the list with the list's compare function,
+On the other hand, `cxListFind()` searches for the element pointed to by `elem` by comparing each element in the list with the list's compare function
 and returns the first index when the element was found.
 Otherwise, the function returns the list size.
 The function `cxListFindRemove()` behaves like `cxListFind()`, except that it also removes the first occurrence of the element from the list.
 This will _also_ call destructor functions, if specified, so take special care when you continue to use `elem`, or when the list is storing pointers and the element appears more than once in the list.
-The function `cxListContains()` returns `true`, if and only if `cxListFind()` would return a valid index.
+The function `cxListContains()` returns `true` if and only if `cxListFind()` returns a valid index.
 With `cxListIndexValid()` you can check the index returned by `cxListFind()` or `cxListFindRemove()`,
 which is more convenient than comparing the return value if the return value of `cxListSize()`.
 ## Remove
 This will _also_ call destructor functions, if specified, so take special care when you continue to use `elem`.
 On the other hand, `cxListRemoveAndGet()` family of functions do not invoke the destructor functions
 and instead copy the elements into the `targetbuf`, which must be large enough to hold the removed elements.
-> Note, that when the list was initialized with `CX_STORE_POINTERS`,
+> Note that when the list was initialized with `CX_STORE_POINTERS`,
 > the elements that will be copied to the `targetbuf` are the _pointers_.
 > In contrast to other list functions, like `cxListAt()`, an automatic dereferencing does not happen here.
 >{style="note"}
 The function `cxListClear()` simply removes all elements from the list, invoking the destructor functions.
-It behaves equivalently, but is usually more efficient than calling `cxListRemove()` for every index.
+It behaves equivalently but is usually more efficient than calling `cxListRemove()` for every index.
 ## Iterators
 ```C
 #include <cx/list.h>
 that start and the first or the last element in the list and iterate through the entire list.
 The functions `cxListIteratorAt()` and `cxListBackwardsIteratorAt()` start with the element at the specified index
 and iterate until the end, or the beginning of the list, respectively.
-The functions with `Mut` in are equivalently, except that they create a [mutating iterator](iterator.h.md#mutating-iterators).
+The functions with `Mut` in are equivalent, except that they create a [mutating iterator](iterator.h.md#mutating-iterators).
 Removing elements via a mutating iterator will cause an invocation of the [destructor functions](collection.h.md#destructor-functions) for the removed element.
-If is safe to specify an out-of-bounds index, or a `NULL` pointer, in which cases the returned iterator will behave like an iterator over an empty list.
+It is safe to specify an out-of-bounds index, or a `NULL` pointer, in which cases the returned iterator will behave like an iterator over an empty list.
 ## Reorder
 ```C
 #include <cx/list.h>
 ```
 The function `cxListSwap()` swaps two elements specified by the indices `i` and `j`.
 The return value is non-zero if one of the indices is out-of-bounds.
-The function `cxListReverse()` reorders all elements, so that they appear in exactly the opposite order after invoking this function.
+The function `cxListReverse()` reorders all elements so that they appear in exactly the opposite order after invoking this function.
 The function `cxListSort()` sorts all elements with respect to the list's compare function,
 unless the list is already sorted (cf. `cxCollectionSorted()`), in which case the function immediately returns.
 Default UCX implementations of the list interface make use of [small buffer optimizations](install.md#small-buffer-optimizations) when swapping elements.
 > An invocation of `cxListSort` sets the `sorted` flag of the [collection](collection.h.md).
 > Implementations usually make use of this flag to optimize search operations, if possible.
 > For example, the [array list](array_list.h.md) implementation will use binary search
-> for `cxListFind()` and similar operations, when the list is sorted.
+> for `cxListFind()` and similar operations when the list is sorted.
 ## Compare
 ```C
 #include <cx/list.h>
 and you could even compare lists that are storing pointers with lists that are not storing pointers.
 However, the optimized list-internal compare implementation is only used when both the compare functions and the list classes are identical.
 Otherwise, `cxListCompare()` will behave as if you were iterating through both lists and manually comparing the elements.
-The return value of `cxListCompare()` is zero, if the lists are element-wise equivalent.
+The return value of `cxListCompare()` is zero if the lists are element-wise equivalent.
 If they are not, the non-zero return value equals the return value of the used compare function for the first pair of elements that are not equal.
 ## Dispose
 ```C
 | `sort`           | Sort all elements in the list with respect to the list's compare function.                                                                                                                                                                                                                                                 |
 | `compare`        | Only function pointer that may be `NULL`, in which case an unoptimized fallback is used. You can implement an optimized compare function that compares the list of another list of the same class.                                                                                                                         |
 | `reverse`        | Reorders all elements in the list so that they appear in exactly the opposite order.                                                                                                                                                                                                                                       |
 | `iterator`       | Creates an iterator starting at the specified index. The Boolean argument indicates whether iteration is supposed to traverse backwards.                                                                                                                                                                                   |
-> If you initialize your list with `cx_list_init()` you do not have to worry about making a
+> If you initialize your list with `cx_list_init()`, you do not have to worry about making a
 > difference between storing pointers and storing elements, because your implementation will
 > be automatically wrapped.
 > This means you only have to handle the one single case described above.
 ### Default Class Function Implementations

Mercurial > hg > ucx / file comparison

comparison: docs/Writerside/topics/list.h.md

docs/Writerside/topics/list.h.md