Download wemm/include/tkArray.h from ZTWHHH/envs_2: direct link, hf CLI and curl.
- Browser
- Download file 18.4 kB
-
https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/wemm/include/tkArray.h
- Command line
-
hf download hf://datasets/ZTWHHH/envs_2/wemm/include/tkArray.h
-
curl -L -o tkArray.h https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/wemm/include/tkArray.h
18.4 kB
| /* | |
| * tkArray.h -- | |
| * | |
| * An array is a sequence of items, stored in a contiguous memory region. | |
| * Random access to any item is very fast. New items can be either appended | |
| * or prepended. An array may be traversed in the forward or backward direction. | |
| * | |
| * Copyright (c) 2018-2019 Gregor Cramer. | |
| * | |
| * See the file "license.terms" for information on usage and redistribution of | |
| * this file, and for a DISCLAIMER OF ALL WARRANTIES. | |
| */ | |
| /* | |
| * Note that this file will not be included in header files, it is the purpose | |
| * of this file to be included in source files only. Thus we are not using the | |
| * prefix "Tk_" here for functions, because all the functions have private scope. | |
| */ | |
| /* | |
| * ------------------------------------------------------------------------------- | |
| * Use the array in the following way: | |
| * ------------------------------------------------------------------------------- | |
| * typedef struct { int key, value; } Pair; | |
| * TK_PTR_ARRAY_DEFINE(MyArray, Pair); | |
| * MyArray *arr = NULL; | |
| * if (MyArray_IsEmpty(arr)) { | |
| * MyArray_Append(&arr, MakePair(1, 2)); | |
| * MyArray_Append(&arr, MakePair(2, 3)); | |
| * for (i = 0; i < MyArray_Size(arr); ++i) { | |
| * Pair *p = MyArray_Get(arr, i); | |
| * printf("%d -> %d\n", p->key, p->value); | |
| * ckfree(p); | |
| * } | |
| * MyArray_Free(&arr); | |
| * assert(arr == NULL); | |
| * } | |
| * ------------------------------------------------------------------------------- | |
| * Or with aggregated elements: | |
| * ------------------------------------------------------------------------------- | |
| * typedef struct { int key, value; } Pair; | |
| * TK_ARRAY_DEFINE(MyArray, Pair); | |
| * Pair p1 = { 1, 2 }; | |
| * Pair p2 = { 2, 3 }; | |
| * MyArray *arr = NULL; | |
| * if (MyArray_IsEmpty(arr)) { | |
| * MyArray_Append(&arr, p1); | |
| * MyArray_Append(&arr, p2); | |
| * for (i = 0; i < MyArray_Size(arr); ++i) { | |
| * const Pair *p = MyArray_Get(arr, i); | |
| * printf("%d -> %d\n", p->key, p->value); | |
| * } | |
| * MyArray_Free(&arr); | |
| * assert(arr == NULL); | |
| * } | |
| * ------------------------------------------------------------------------------- | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Two array types will be provided: | |
| * Use TK_ARRAY_DEFINE if your array is aggregating the elements. Use | |
| * TK_PTR_ARRAY_DEFINE if your array contains pointers to elements. But | |
| * in latter case the array is not responsible for the lifetime of the | |
| * elements. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_ElemSize: Returns the memory size for one array element. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_BufferSize: Returns the memory size for given number of elements. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_IsEmpty: Array is empty? | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Size: Number of elements in array. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Capacity: Capacity of given array. This is the maximal number of | |
| * elements fitting into current array memory without resizing the buffer. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_SetSize: Set array size, new size must not exceed the capacity of | |
| * the array. This function has to be used with care when increasing the | |
| * array size. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_First: Returns position of first element in array. Given array | |
| * may be NULL. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Last: Returns position after last element in array. Given array | |
| * may be empty. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Front: Returns first element in array. Given array must not be | |
| * empty. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Back: Returns last element in array. Given array must not be | |
| * empty. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Resize: Resize buffer of array for given number of elements. The | |
| * array may grow or shrink. Note that this function is not initializing | |
| * the increased buffer. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_ResizeAndClear: Resize buffer of array for given number of | |
| * elements. The array may grow or shrink. The increased memory will be | |
| * filled with zeroes. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Clear: Fill specified range with zeroes. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Free: Resize array to size zero. This function will release the | |
| * array buffer. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Append: Insert given element after end of array. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_PopBack: Shrink array by one element. Given array must not be | |
| * empty. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Get: Random access to array element at given position. The given | |
| * index must not exceed current array size. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Set: Replace array element at given position with new value. The | |
| * given index must not exceed current array size. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Array_Find: Return index position of element which matches given | |
| * argument. If not found then -1 will be returned. | |
| */ | |
| /*************************************************************************/ | |
| /* | |
| * Local Variables: | |
| * mode: c | |
| * c-basic-offset: 4 | |
| * fill-column: 105 | |
| * End: | |
| * vi:set ts=8 sw=4: | |
| */ | |