libsheepyCSmallArray.h (129469B)
1 // MIT License 2 // 3 // Copyright (c) 2026 Remy Noulin 4 // 5 // Permission is hereby granted, free of charge, to any person obtaining a copy 6 // of this software and associated documentation files (the "Software"), to deal 7 // in the Software without restriction, including without limitation the rights 8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 // copies of the Software, and to permit persons to whom the Software is 10 // furnished to do so, subject to the following conditions: 11 // 12 // The above copyright notice and this permission notice shall be included in all 13 // copies or substantial portions of the Software. 14 // 15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 // SOFTWARE. 22 #pragma once 23 24 // note: this file is generated, edit the source *_pp.h 25 26 27 // Class smallArray 28 typedef struct smallArray smallArrayt; 29 30 /** 31 * help text for this class 32 * It is public declaration so that child classes can add their help text easily: 33 * ret "Child help text \n\n" helpTextSmallArray; 34 */ 35 #define helpTextSmallArray "TODO smallArray help brief, class description /*, definitions,*/ methods, examples" 36 37 // for object inheriting smallArray, cast to smallArray to be able to use this class functions and generics 38 #define cAr(self) ( (smallArrayt*) self ) 39 40 typedef void (*freeSmallArrayFt) (smallArrayt *self); 41 typedef void (*terminateSmallArrayFt) (smallArrayt **self); 42 typedef char* (*toStringSmallArrayFt) (smallArrayt *self); 43 typedef smallArrayt* (*duplicateSmallArrayFt) (smallArrayt *self); 44 45 typedef char* (*escapeSmallArrayFt) (smallArrayt *self); 46 47 /** 48 * free index but not the elements 49 * self becomes empty. 50 * 51 * Useful when the objects are shared 52 */ 53 typedef void (*disposeSmallArrayFt) (smallArrayt *self); 54 55 /** 56 * free self but not the elements 57 * self becomes empty. 58 * 59 * Useful when the objects are shared 60 */ 61 typedef void (*smashSmallArrayFt) (smallArrayt **self); 62 63 /** 64 * free container 65 */ 66 typedef void (*finishSmallArrayFt) (smallArrayt **self); 67 68 typedef const char* (*helpSmallArrayFt) (smallArrayt *self); 69 70 /** 71 * remove reference to internal sObject, set NULL and 72 * free the iterator 73 * 74 * this function is useful for object not allocated on the heap 75 * to free the iterator element when the object is not used anymore 76 * 77 * for example: 78 * createSmallArray(array); 79 * iter(array, e) { 80 * ... 81 * break; 82 * } 83 * resetG(array); // free iteraror element 84 * 85 */ 86 typedef void (*resetSmallArrayFt) (smallArrayt *self); 87 88 /** 89 * get the sobject, data in the container 90 */ 91 typedef sArrayt* (*getsoSmallArrayFt) (smallArrayt *self); 92 93 /** 94 * set the sobject, data in the container 95 * the iterator is reset 96 */ 97 typedef void (*setsoSmallArrayFt) (smallArrayt *self, sArrayt *so); 98 99 /** 100 * allocate a new container for the sobject, the iterator state is copied 101 * after this function is executed, there are 2 containers for one sobject, 102 * only one container should be freed or terminated, the other one should be finished 103 */ 104 typedef smallArrayt* (*mirrorSmallArrayFt) (smallArrayt *self); 105 106 /** 107 * copy array of 'size' to self 108 * NULL elements are not copied to the list 109 * 110 * \param 111 * array 112 * \param 113 * size number of elements in the array, size 0 means NULL terminated array 114 * \return 115 * list 116 * empty list when size is 0 117 * NULL when array is NULL 118 */ 119 typedef smallArrayt* (*fromArraySmallArrayFt)(smallArrayt *self, char **array, size_t size); 120 typedef smallArrayt* (*fromCArraySmallArrayFt)(smallArrayt *self, const char **array, size_t size); 121 typedef smallArrayt* (*fromArrayNFreeSmallArrayFt)(smallArrayt *self, char **array, size_t size); 122 123 /** 124 * push the sObject pointer to array 125 * append value at the end of the list 126 * when s is NULL, NULL is pushed at the end of the list 127 * 128 * When the sObject pointer is updated by realloc, the sObject 129 * pointer in the smallArray has to be updated with setP. 130 * The operations reallocating the sObjects are: 131 * smallDict: push, set, trim, merge, append 132 * smallArray: push, prepend 133 * smallBytes: push, pushBuffer 134 * smallJson: push, set 135 * smallString: append, prepend, replace, intTo, insert, color, readFile 136 * 137 * The object is duplicated for: 138 * char * 139 * 140 * When self is an array which is an element of a smallArray, smallDict, the setP function in 141 * the parent object has to be called to update the sObject pointer (which is inside self). 142 * 143 * \param 144 * value: object to push 145 * \return 146 * self success 147 * NULL error 148 */ 149 typedef smallArrayt* (*pushSmallArrayFt) (smallArrayt *self, baset *value); 150 typedef smallArrayt* (*pushUndefinedSmallArrayFt) (smallArrayt *self); 151 typedef smallArrayt* (*pushBoolSmallArrayFt) (smallArrayt *self, bool value); 152 typedef smallArrayt* (*pushDoubleSmallArrayFt) (smallArrayt *self, double value); 153 typedef smallArrayt* (*pushIntSmallArrayFt) (smallArrayt *self, int64_t value); 154 typedef smallArrayt* (*pushSSmallArrayFt) (smallArrayt *self, const char *string); 155 typedef smallArrayt* (*pushCharSmallArrayFt) (smallArrayt *self, char c); 156 typedef smallArrayt* (*pushDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 157 typedef smallArrayt* (*pushArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 158 typedef smallArrayt* (*pushArraycSmallArrayFt) (smallArrayt *self, char **array); 159 typedef smallArrayt* (*pushCArraycSmallArrayFt) (smallArrayt *self, const char **array); 160 typedef smallArrayt* (*pushSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 161 typedef smallArrayt* (*pushSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 162 typedef smallArrayt* (*pushSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 163 typedef smallArrayt* (*pushSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 164 typedef smallArrayt* (*pushSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *value); 165 typedef smallArrayt* (*pushSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 166 typedef smallArrayt* (*pushSmallContainerSmallArrayFt) (smallArrayt *self, smallContainert *container); 167 168 /** 169 * push element and free 170 * 171 * value container is freed at the end of the function 172 * Example: when setting a smallString, it is copied to an sStringt and then the object is freed 173 * 174 * \param 175 * value an object 176 */ 177 typedef smallArrayt* (*pushNFreeSmallArrayFt) (smallArrayt *self, baset *value); 178 typedef smallArrayt* (*pushNFreeUndefinedSmallArrayFt) (smallArrayt *self, undefinedt *undefined); 179 typedef smallArrayt* (*pushNFreeSSmallArrayFt) (smallArrayt *self, char *string); 180 typedef smallArrayt* (*pushNFreeDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 181 typedef smallArrayt* (*pushNFreeArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 182 typedef smallArrayt* (*pushNFreeArraycSmallArrayFt) (smallArrayt *self, char **array); 183 typedef smallArrayt* (*pushNFreeSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 184 typedef smallArrayt* (*pushNFreeSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 185 typedef smallArrayt* (*pushNFreeSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 186 typedef smallArrayt* (*pushNFreeSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 187 typedef smallArrayt* (*pushNFreeSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *value); 188 typedef smallArrayt* (*pushNFreeSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 189 typedef smallArrayt* (*pushNFreeSmallContainerSmallArrayFt)(smallArrayt *self, smallContainert *container); 190 191 /** 192 * push many elements 193 * 194 * \param 195 * arbitrary list of smallObject elements seperated by commas 196 */ 197 typedef smallArrayt* (*pushManySmallArrayFt) (smallArrayt *self, ...); 198 199 /** 200 * push many string elements 201 * 202 * \param 203 * arbitrary list of char* string elements seperated by commas 204 */ 205 typedef smallArrayt* (*pushManySSmallArrayFt) (smallArrayt *self, ...); 206 207 /** 208 * push many elements and free 209 * 210 * \param 211 * arbitrary list of smallObject elements seperated by commas 212 */ 213 typedef smallArrayt* (*pushNFreeManySmallArrayFt) (smallArrayt *self, ...); 214 215 /** 216 * push many string elements and free 217 * 218 * \param 219 * arbitrary list of char* string elements seperated by commas 220 */ 221 typedef smallArrayt* (*pushNFreeManySSmallArrayFt)(smallArrayt *self, ...); 222 223 224 /** 225 * pop object 226 * return last object from list and remove last element from the list 227 * 228 * \return 229 * last object pointer 230 * NULL when the list is NULL or empty (first element is NULL) 231 */ 232 typedef baset* (*popSmallArrayFt) (smallArrayt *self); 233 typedef undefinedt* (*popUndefinedSmallArrayFt) (smallArrayt *self); 234 typedef bool (*popBoolSmallArrayFt) (smallArrayt *self); 235 typedef double (*popDoubleSmallArrayFt) (smallArrayt *self); 236 typedef int64_t (*popIntSmallArrayFt) (smallArrayt *self); 237 typedef int32_t (*popInt32SmallArrayFt) (smallArrayt *self); 238 typedef uint64_t (*popUintSmallArrayFt) (smallArrayt *self); 239 typedef uint32_t (*popUint32SmallArrayFt) (smallArrayt *self); 240 typedef char* (*popSSmallArrayFt) (smallArrayt *self); 241 typedef smallDictt* (*popDictSmallArrayFt) (smallArrayt *self); 242 typedef smallArrayt* (*popArraySmallArrayFt) (smallArrayt *self); 243 typedef smallBoolt* (*popSmallBoolSmallArrayFt) (smallArrayt *self); 244 typedef smallBytest* (*popSmallBytesSmallArrayFt) (smallArrayt *self); 245 typedef smallDoublet* (*popSmallDoubleSmallArrayFt) (smallArrayt *self); 246 typedef smallIntt* (*popSmallIntSmallArrayFt) (smallArrayt *self); 247 typedef smallJsont* (*popSmallJsonSmallArrayFt) (smallArrayt *self); 248 typedef smallStringt* (*popSmallStringSmallArrayFt) (smallArrayt *self); 249 typedef void* (*popVoidSmallArrayFt) (smallArrayt *self); 250 typedef smallContainert* (*popSmallContainerSmallArrayFt)(smallArrayt *self); 251 252 /** 253 * pop number 254 * 255 * if the element is a double, its value is returned as is 256 * if the element is an int, its value is converted to double 257 * if the element is not a number, 0 is returned 258 * 259 * \return 260 * double type number or 0 261 */ 262 typedef double (*popNumSmallArrayFt) (smallArrayt *self); 263 264 /** 265 * prepend object 266 * append object pointer at the beginning of the list 267 * when value is NULL, the operation is canceled 268 * 269 * When the sObject pointer is updated by realloc, the sObject 270 * pointer in the smallArray has to be updated with setP. 271 * The operations reallocating the sObjects are: 272 * smallDict: push, set, trim, merge, append 273 * smallArray: push, prepend 274 * smallBytes: push, pushBuffer 275 * smallJson: push, set 276 * smallString: append, prepend, replace, intTo, insert, color, readFile 277 * 278 * The object is duplicated for: 279 * char * 280 * 281 * When self is an array which is an element of a smallArray, smallDict, the setP function in 282 * the parent object has to be called to update the sObject pointer (which is inside self). 283 * 284 * \param 285 * value string to prepend 286 * \return 287 * self 288 */ 289 typedef smallArrayt* (*prependSmallArrayFt) (smallArrayt *self, baset *value); 290 typedef smallArrayt* (*prependUndefinedSmallArrayFt) (smallArrayt *self); 291 typedef smallArrayt* (*prependBoolSmallArrayFt) (smallArrayt *self, bool value); 292 typedef smallArrayt* (*prependDoubleSmallArrayFt) (smallArrayt *self, double value); 293 typedef smallArrayt* (*prependIntSmallArrayFt) (smallArrayt *self, int64_t value); 294 typedef smallArrayt* (*prependSSmallArrayFt) (smallArrayt *self, const char *string); 295 typedef smallArrayt* (*prependCharSmallArrayFt) (smallArrayt *self, char c); 296 typedef smallArrayt* (*prependDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 297 typedef smallArrayt* (*prependArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 298 typedef smallArrayt* (*prependArraycSmallArrayFt) (smallArrayt *self, char **array); 299 typedef smallArrayt* (*prependCArraycSmallArrayFt) (smallArrayt *self, const char **array); 300 typedef smallArrayt* (*prependSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 301 typedef smallArrayt* (*prependSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 302 typedef smallArrayt* (*prependSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 303 typedef smallArrayt* (*prependSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 304 typedef smallArrayt* (*prependSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *json); 305 typedef smallArrayt* (*prependSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 306 typedef smallArrayt* (*prependSmallContainerSmallArrayFt) (smallArrayt *self, smallContainert *container); 307 308 typedef smallArrayt* (*prependNFreeSmallArrayFt) (smallArrayt *self, baset *value); 309 typedef smallArrayt* (*prependNFreeUndefinedSmallArrayFt) (smallArrayt *self, undefinedt *undefined); 310 typedef smallArrayt* (*prependNFreeSSmallArrayFt) (smallArrayt *self, char *string); 311 typedef smallArrayt* (*prependNFreeDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 312 typedef smallArrayt* (*prependNFreeArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 313 typedef smallArrayt* (*prependNFreeArraycSmallArrayFt) (smallArrayt *self, char **array); 314 typedef smallArrayt* (*prependNFreeSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 315 typedef smallArrayt* (*prependNFreeSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 316 typedef smallArrayt* (*prependNFreeSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 317 typedef smallArrayt* (*prependNFreeSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 318 typedef smallArrayt* (*prependNFreeSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *json); 319 typedef smallArrayt* (*prependNFreeSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 320 typedef smallArrayt* (*prependNFreeSmallContainerSmallArrayFt)(smallArrayt *self, smallContainert *container); 321 322 /** 323 * dequeue object 324 * return first object from list and remove it from the list 325 * 326 * \return 327 * first object 328 * NULL when the list is NULL or empty (first element is NULL) 329 */ 330 typedef baset* (*dequeueSmallArrayFt) (smallArrayt *self); 331 typedef undefinedt* (*dequeueUndefinedSmallArrayFt) (smallArrayt *self); 332 typedef bool (*dequeueBoolSmallArrayFt) (smallArrayt *self); 333 typedef double (*dequeueDoubleSmallArrayFt) (smallArrayt *self); 334 typedef int64_t (*dequeueIntSmallArrayFt) (smallArrayt *self); 335 typedef int32_t (*dequeueInt32SmallArrayFt) (smallArrayt *self); 336 typedef uint64_t (*dequeueUintSmallArrayFt) (smallArrayt *self); 337 typedef uint32_t (*dequeueUint32SmallArrayFt) (smallArrayt *self); 338 typedef char* (*dequeueSSmallArrayFt) (smallArrayt *self); 339 typedef smallDictt* (*dequeueDictSmallArrayFt) (smallArrayt *self); 340 typedef smallArrayt* (*dequeueArraySmallArrayFt) (smallArrayt *self); 341 typedef smallBoolt* (*dequeueSmallBoolSmallArrayFt) (smallArrayt *self); 342 typedef smallBytest* (*dequeueSmallBytesSmallArrayFt) (smallArrayt *self); 343 typedef smallDoublet* (*dequeueSmallDoubleSmallArrayFt) (smallArrayt *self); 344 typedef smallIntt* (*dequeueSmallIntSmallArrayFt) (smallArrayt *self); 345 typedef smallJsont* (*dequeueSmallJsonSmallArrayFt) (smallArrayt *self); 346 typedef smallStringt* (*dequeueSmallStringSmallArrayFt) (smallArrayt *self); 347 typedef void* (*dequeueVoidSmallArrayFt) (smallArrayt *self); 348 typedef smallContainert* (*dequeueSmallContainerSmallArrayFt)(smallArrayt *self); 349 350 /** 351 * dequeue number 352 * 353 * if the element is a double, its value is returned as is 354 * if the element is an int, its value is converted to double 355 * if the element is not a number, 0 is returned 356 * 357 * \return 358 * double type number or 0 359 */ 360 typedef double (*dequeueNumSmallArrayFt) (smallArrayt *self); 361 362 /** 363 * reverse list, the last element is the first element of the list 364 * 365 * \return 366 * reversed list 367 * nothing when list is NULL 368 * 0 success 369 * -1 error 370 */ 371 typedef smallArrayt* (*reverseSmallArrayFt) (smallArrayt *self); 372 373 374 /** 375 * cat arrays 376 * 377 * append all arrays in the list to self 378 * 379 * \param 380 * arbitrary list of arrays seperated by commas 381 */ 382 typedef smallArrayt* (*catSmallArrayFt) (smallArrayt *self, ...); 383 384 /** 385 * append array at the end of self by copying the pointers 386 * from array to self. 387 * After this function, free array with dispose/smash instead of free/terminate 388 * 389 * \param 390 * array 391 * \return 392 * self and array in self 393 * self not modified when self and array are NULL 394 * or when self is identical to array (same pointers) 395 * 0 success 396 * -1 error 397 */ 398 typedef smallArrayt* (*appendSmallArrayFt) (smallArrayt *self, smallArrayt *array); 399 typedef smallArrayt* (*appendSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *json); 400 typedef smallArrayt* (*appendNSmashSmallArrayFt) (smallArrayt *self, smallArrayt *array); 401 typedef smallArrayt* (*appendNSmashSmallJsonSmallArrayFt)(smallArrayt *self, smallJsont *json); 402 typedef smallArrayt* (*appendArraySmallArrayFt) (smallArrayt *self, char **array); 403 typedef smallArrayt* (*appendCArraySmallArrayFt) (smallArrayt *self, const char **array); 404 typedef smallArrayt* (*appendNSmashArraySmallArrayFt) (smallArrayt *self, char **array); 405 406 /** 407 * prepend array at the start of self by copying the pointers 408 * from array to self. 409 * After this function, free array with dispose/smash instead of free/terminate 410 * 411 * \param 412 * array 413 * \return 414 * self and array in self 415 * self not modified when self and array are NULL 416 * or when self is identical to array (same pointers) 417 * 0 success 418 * -1 error 419 */ 420 typedef smallArrayt* (*shiftSmallArrayFt) (smallArrayt *self, smallArrayt *array); 421 typedef smallArrayt* (*shiftSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *json); 422 typedef smallArrayt* (*shiftNSmashSmallArrayFt) (smallArrayt *self, smallArrayt *array); 423 typedef smallArrayt* (*shiftNSmashSmallJsonSmallArrayFt)(smallArrayt *self, smallJsont *json); 424 425 /** 426 * add self and list in a new list 427 * 428 * \param 429 * list 430 * \return 431 * new list with self and list 432 * empty list when self and list are NULL or empty 433 */ 434 typedef smallArrayt* (*addSmallArrayFt) (smallArrayt *self, smallArrayt *array); 435 436 /** 437 * keep elements from start and end in array, free the other elements 438 * negative indexes are allowed 439 * 440 * \param 441 * start index, must be in the array 442 * \param 443 * end index, must be in the array 444 * \return 445 * sliced array 446 * empty array when start=end 447 * unchanged when array is empty 448 * unchanged when array is NULL or when start and end are not set correctly 449 * 0 success 450 * -1 error 451 */ 452 typedef smallArrayt* (*sliceSmallArrayFt) (smallArrayt *self, int64_t start, int64_t end); 453 454 /** 455 * Crop elements from start to end 456 * return a new list with elements from start and end in list 457 * and delete elements from start to end in the original list 458 * negative indexes are allowed 459 * 460 * Crop is faster than Slice+Del because only the 461 * pointers are copied to the sliced list 462 * 463 * \param 464 * start index, must be in the list 465 * \param 466 * end index, must be in the list 467 * \return 468 * new sliced list (you must free (terminate) the pointer) 469 * empty list when start=end 470 * unchanged when list is empty 471 * unchanged when list is NULL or when start and end are not set correctly 472 * NULL error 473 */ 474 typedef smallArrayt* (*cropSmallArrayFt) (smallArrayt *self, int64_t start, int64_t end); 475 476 477 /** 478 * Crop a single Element 479 * return element at index 480 * and delete element at index in the original list 481 * negative indexes are allowed 482 * 483 * \param 484 * index must be in the list 485 * \return 486 * element at index (you must free the pointer (terminate libsheepy objects)) 487 * unchanged when list is empty 488 * NULL error 489 */ 490 typedef baset* (*cropElemSmallArrayFt) (smallArrayt *self, int64_t index); 491 typedef undefinedt* (*cropElemUndefinedSmallArrayFt) (smallArrayt *self, int64_t index); 492 typedef bool (*cropElemBoolSmallArrayFt) (smallArrayt *self, int64_t index); 493 typedef double (*cropElemDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 494 typedef int64_t (*cropElemIntSmallArrayFt) (smallArrayt *self, int64_t index); 495 typedef int32_t (*cropElemInt32SmallArrayFt) (smallArrayt *self, int64_t index); 496 typedef uint64_t (*cropElemUintSmallArrayFt) (smallArrayt *self, int64_t index); 497 typedef uint32_t (*cropElemUint32SmallArrayFt) (smallArrayt *self, int64_t index); 498 typedef char* (*cropElemSSmallArrayFt) (smallArrayt *self, int64_t index); 499 typedef smallDictt* (*cropElemDictSmallArrayFt) (smallArrayt *self, int64_t index); 500 typedef smallArrayt* (*cropElemArraySmallArrayFt) (smallArrayt *self, int64_t index); 501 typedef smallBoolt* (*cropElemSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index); 502 typedef smallBytest* (*cropElemSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index); 503 typedef smallDoublet* (*cropElemSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 504 typedef smallIntt* (*cropElemSmallIntSmallArrayFt) (smallArrayt *self, int64_t index); 505 typedef smallJsont* (*cropElemSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index); 506 typedef smallStringt* (*cropElemSmallStringSmallArrayFt) (smallArrayt *self, int64_t index); 507 typedef void* (*cropElemVoidSmallArrayFt) (smallArrayt *self, int64_t index); 508 typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *self, int64_t index); 509 510 /** 511 * keep elements from start and end in list, free the other elements 512 * negative indexes are allowed 513 * 514 * \param 515 * start index, must be in the list 516 * \param 517 * end index, must be in the list 518 * \return 519 * new sliced list 520 * empty list when start=end 521 * unchanged when list is empty 522 * unchanged when list is NULL or when start and end are not set correctly 523 * NULL error 524 */ 525 typedef smallArrayt* (*copySmallArrayFt) (smallArrayt *self, int64_t start, int64_t end); 526 527 /** 528 * insert array in self at index 529 * After this function, free toInsert with dispose/smash instead of free/terminate 530 * 531 * return array with toInsert at index 532 * negative indexes are allowed 533 * 534 * \param 535 * index in array 536 * \param 537 * toInsert array 538 * \return 539 * array 540 * unchanged array when array is NULL or invalid index 541 * NULL error 542 */ 543 typedef smallArrayt* (*insertSmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *toInsert); 544 typedef smallArrayt* (*insertSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *toInsert); 545 typedef smallArrayt* (*insertNSmashSmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *toInsert); 546 typedef smallArrayt* (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *self, int64_t index, smallJsont *toInsert); 547 548 /** 549 * inject an element in self at index 550 * 551 * return array with toInject at index 552 * negative indexes are allowed 553 * 554 * \param 555 * index in array 556 * \param 557 * toInject element 558 * \return 559 * array 560 * unchanged array when array is NULL or invalid index 561 * NULL error 562 */ 563 typedef smallArrayt* (*injectSmallArrayFt) (smallArrayt *self, int64_t index, baset *toInject); 564 typedef smallArrayt* (*injectUndefinedSmallArrayFt)(smallArrayt *self, int64_t index); 565 typedef smallArrayt* (*injectBoolSmallArrayFt) (smallArrayt *self, int64_t index, bool toInject); 566 typedef smallArrayt* (*injectDoubleSmallArrayFt) (smallArrayt *self, int64_t index, double toInject); 567 typedef smallArrayt* (*injectIntSmallArrayFt) (smallArrayt *self, int64_t index, int64_t toInject); 568 typedef smallArrayt* (*injectSSmallArrayFt) (smallArrayt *self, int64_t index, const char *toInject); 569 typedef smallArrayt* (*injectCharSmallArrayFt) (smallArrayt *self, int64_t index, char c); 570 typedef smallArrayt* (*injectDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *toInject); 571 typedef smallArrayt* (*injectArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *toInject); 572 typedef smallArrayt* (*injectArraycSmallArrayFt) (smallArrayt *self, int64_t index, char **toInject); 573 typedef smallArrayt* (*injectCArraycSmallArrayFt) (smallArrayt *self, int64_t index, const char **toInject); 574 typedef smallArrayt* (*injectSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index, smallBoolt *toInject); 575 typedef smallArrayt* (*injectSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index, smallBytest *toInject); 576 typedef smallArrayt* (*injectSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index, smallDoublet *toInject); 577 typedef smallArrayt* (*injectSmallIntSmallArrayFt) (smallArrayt *self, int64_t index, smallIntt *toInject); 578 typedef smallArrayt* (*injectSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *toInject); 579 typedef smallArrayt* (*injectSmallStringSmallArrayFt) (smallArrayt *self, int64_t index, smallStringt *toInject); 580 typedef smallArrayt* (*injectSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject); 581 582 typedef smallArrayt* (*injectNFreeSmallArrayFt) (smallArrayt *self, int64_t index, baset *toInject); 583 typedef smallArrayt* (*injectNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined); 584 typedef smallArrayt* (*injectNFreeSSmallArrayFt) (smallArrayt *self, int64_t index, char *toInject); 585 typedef smallArrayt* (*injectNFreeDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *toInject); 586 typedef smallArrayt* (*injectNFreeArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *toInject); 587 typedef smallArrayt* (*injectNFreeArraycSmallArrayFt) (smallArrayt *self, int64_t index, char **toInject); 588 typedef smallArrayt* (*injectNFreeSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index, smallBoolt *toInject); 589 typedef smallArrayt* (*injectNFreeSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index, smallBytest *toInject); 590 typedef smallArrayt* (*injectNFreeSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index, smallDoublet *toInject); 591 typedef smallArrayt* (*injectNFreeSmallIntSmallArrayFt) (smallArrayt *self, int64_t index, smallIntt *toInject); 592 typedef smallArrayt* (*injectNFreeSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *toInject); 593 typedef smallArrayt* (*injectNFreeSmallStringSmallArrayFt) (smallArrayt *self, int64_t index, smallStringt *toInject); 594 typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject); 595 596 /** 597 * remove (free) elements from start and end in self 598 * negative indexes are allowed 599 * 600 * \param 601 * start index, must be in the array 602 * end index, must be in the array 603 * \return 604 * sliced array 605 * array copy when start=end or when start and end are not set correctly 606 * NULL when array is empty 607 * NULL when array is NULL or when end is under start 608 * 0 success 609 * -1 error 610 */ 611 typedef smallArrayt* (*delSmallArrayFt) (smallArrayt *self, int64_t start, int64_t end); 612 613 /** 614 * delete element 615 * 616 * free element sObject at index 617 * this function is to be used before dispose to free some elements 618 * For example: 619 * createSmallArray(a); 620 * smallStringt *s = allocG("the element to keep"); 621 * pushG(a, "The element to free"); 622 * pushG(a, s); 623 * 624 * The array a is: ["The element to free", "the element to keep"] 625 * 626 * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem 627 * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed 628 */ 629 typedef smallArrayt* (*delElemSmallArrayFt) (smallArrayt *self, int64_t index); 630 631 /** 632 * remove without freeing elements from start and end in self 633 * negative indexes are allowed 634 * 635 * \param 636 * start index, must be in the array 637 * end index, must be in the array 638 * \return 639 * sliced array 640 * array copy when start=end or when start and end are not set correctly 641 * NULL when array is empty 642 * NULL when array is NULL or when end is under start 643 * 0 success 644 * -1 error 645 */ 646 typedef smallArrayt* (*removeSmallArrayFt) (smallArrayt *self, int64_t start, int64_t end); 647 648 /** 649 * remove without freeing element 650 * 651 * remove without freeing element sObject at index 652 * 653 * Example: 654 * cleanAllocateSmallString(S); 655 * setValG(S, "sString object"); 656 * cleanAllocateSmallArray(a); 657 * // set an object shared with another container in the array a 658 * // "sString object" is in both container S and a 659 * pushG(a, S); 660 * pushG(a, "another string"); 661 * // the program deletes element 0 in array a 662 * // to do so, it uses removeElemG since S will free the sString object 663 * removeElemG(a, 0); 664 */ 665 typedef smallArrayt* (*removeElemSmallArrayFt) (smallArrayt *self, int64_t index); 666 667 /** 668 * sort self in alphabetic order 669 * 670 * \return 671 * sorted list 672 * empty list when list is empty 673 * unchanged list when list is NULL 674 * 0 success 675 * -1 error 676 */ 677 typedef smallArrayt* (*sortSmallArrayFt) (smallArrayt *self); 678 679 680 /** 681 * sort self according to the results from the compareFunction function 682 * 683 * shCmpt is defined in libsheepy.h 684 * typedef int (*shCmp)(const void * a, const void * b); 685 * 686 * a and b are baset objects, cast to the correct class by using the object type 687 * 688 * cast macros: castS(s, S) and cast(smallArrayt*, a, A) 689 * 690 * \return 691 * sorted list 692 * NULL error 693 */ 694 typedef smallArrayt* (*sortFSmallArrayFt) (smallArrayt *self, shCmpt compareFunction); 695 696 /** 697 * ignore case sort self in alphabetic order 698 * 699 * \return 700 * sorted list 701 * empty list when list is empty 702 * unchanged list when list is NULL 703 * 0 success 704 * -1 error 705 */ 706 typedef smallArrayt* (*icSortSmallArrayFt) (smallArrayt *self); 707 708 /** 709 * compare each element of self and list 710 * 711 * \param 712 * list 713 * \return 714 * true the lists have identical elements 715 * false they differ 716 */ 717 typedef bool (*equalSmallArrayFt) (smallArrayt *self, smallArrayt *array); 718 typedef bool (*equalSmallArraySmallJsonFt)(smallArrayt *self, smallJsont *array); 719 typedef bool (*equalSmallArrayArrayFt) (smallArrayt* self, char ** p2); 720 typedef bool (*equalSmallArrayCArrayFt) (smallArrayt* self, const char ** p2); 721 typedef bool (*equalSmallArrayBaseFt) (smallArrayt* self, baset* p2); 722 723 /** 724 * ignore case and compare each element of self and list 725 * 726 * \param 727 * list 728 * \return 729 * true the lists have identical elements 730 * false they differ 731 */ 732 typedef bool (*icEqualSmallArrayFt) (smallArrayt *self, smallArrayt *array); 733 typedef bool (*icEqualSmallArraySmallJsonFt)(smallArrayt *self, smallJsont *array); 734 typedef bool (*icEqualSmallArrayArrayFt) (smallArrayt* self, char ** p2); 735 typedef bool (*icEqualSmallArrayCArrayFt) (smallArrayt* self, const char ** p2); 736 typedef bool (*icEqualSmallArrayBaseFt) (smallArrayt* self, baset* p2); 737 738 /** 739 * return number of elements 740 * 741 * \return 742 * number of element 743 * 0 when array is NULL 744 */ 745 typedef size_t (*lenSmallArrayFt) (smallArrayt *self); 746 747 /** 748 * remove NULL elements from array 749 */ 750 typedef smallArrayt* (*trimSmallArrayFt) (smallArrayt *self); 751 752 /** 753 * get object 754 * index can be negative 755 * 756 * \param 757 * index: index in array, must be inside the array 758 * \return 759 * pointer to object 760 * NULL when array is NULL or index is not set correctly 761 */ 762 typedef baset* (*getAtSmallArrayFt) (smallArrayt *self, int64_t index); 763 typedef undefinedt* (*getAtUndefinedSmallArrayFt) (smallArrayt *self, int64_t index); 764 typedef bool (*getAtBoolSmallArrayFt) (smallArrayt *self, int64_t index); 765 typedef bool* (*getAtBoolPSmallArrayFt) (smallArrayt *self, int64_t index); 766 typedef double (*getAtDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 767 typedef double* (*getAtDoublePSmallArrayFt) (smallArrayt *self, int64_t index); 768 typedef int64_t (*getAtIntSmallArrayFt) (smallArrayt *self, int64_t index); 769 typedef int64_t* (*getAtIntPSmallArrayFt) (smallArrayt *self, int64_t index); 770 typedef int32_t (*getAtInt32SmallArrayFt) (smallArrayt *self, int64_t index); 771 typedef int32_t* (*getAtInt32PSmallArrayFt) (smallArrayt *self, int64_t index); 772 typedef uint64_t (*getAtUintSmallArrayFt) (smallArrayt *self, int64_t index); 773 typedef uint64_t* (*getAtUintPSmallArrayFt) (smallArrayt *self, int64_t index); 774 typedef uint32_t (*getAtUint32SmallArrayFt) (smallArrayt *self, int64_t index); 775 typedef uint32_t* (*getAtUint32PSmallArrayFt) (smallArrayt *self, int64_t index); 776 typedef char* (*getAtSSmallArrayFt) (smallArrayt *self, int64_t index); 777 typedef smallDictt* (*getAtDictSmallArrayFt) (smallArrayt *self, int64_t index); 778 typedef smallArrayt* (*getAtArraySmallArrayFt) (smallArrayt *self, int64_t index); 779 typedef smallBoolt* (*getAtSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index); 780 typedef smallBytest* (*getAtSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index); 781 typedef smallDoublet* (*getAtSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 782 typedef smallIntt* (*getAtSmallIntSmallArrayFt) (smallArrayt *self, int64_t index); 783 typedef smallJsont* (*getAtSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index); 784 typedef smallStringt* (*getAtSmallStringSmallArrayFt) (smallArrayt *self, int64_t index); 785 typedef void* (*getAtVoidSmallArrayFt) (smallArrayt *self, int64_t index); 786 typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index); 787 788 /** 789 * get duplicated object 790 * index can be negative 791 * 792 * \param 793 * index: index in array, must be inside the array 794 * \return 795 * duplicated object 796 * NULL when array is NULL or index is not set correctly 797 */ 798 typedef baset* (*getAtNDupSmallArrayFt) (smallArrayt *self, int64_t index); 799 typedef undefinedt* (*getAtNDupUndefinedSmallArrayFt) (smallArrayt *self, int64_t index); 800 typedef bool (*getAtNDupBoolSmallArrayFt) (smallArrayt *self, int64_t index); 801 typedef double (*getAtNDupDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 802 typedef int64_t (*getAtNDupIntSmallArrayFt) (smallArrayt *self, int64_t index); 803 typedef int32_t (*getAtNDupInt32SmallArrayFt) (smallArrayt *self, int64_t index); 804 typedef uint64_t (*getAtNDupUintSmallArrayFt) (smallArrayt *self, int64_t index); 805 typedef uint32_t (*getAtNDupUint32SmallArrayFt) (smallArrayt *self, int64_t index); 806 typedef char* (*getAtNDupSSmallArrayFt) (smallArrayt *self, int64_t index); 807 typedef smallDictt* (*getAtNDupDictSmallArrayFt) (smallArrayt *self, int64_t index); 808 typedef smallArrayt* (*getAtNDupArraySmallArrayFt) (smallArrayt *self, int64_t index); 809 typedef smallBoolt* (*getAtNDupSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index); 810 typedef smallBytest* (*getAtNDupSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index); 811 typedef smallDoublet* (*getAtNDupSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 812 typedef smallIntt* (*getAtNDupSmallIntSmallArrayFt) (smallArrayt *self, int64_t index); 813 typedef smallJsont* (*getAtNDupSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index); 814 typedef smallStringt* (*getAtNDupSmallStringSmallArrayFt) (smallArrayt *self, int64_t index); 815 typedef void* (*getAtNDupVoidSmallArrayFt) (smallArrayt *self, int64_t index); 816 typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index); 817 818 /** 819 * store object at given index (free already existing elements when baset *value is NULL) 820 * index can be negative 821 * 822 * When the sObject pointer is updated by realloc, the sObject 823 * pointer in the smallArray has to be updated with setP. 824 * The operations reallocating the sObjects are: 825 * smallDict: push, set, trim, merge, append 826 * smallArray: push, prepend 827 * smallBytes: push, pushBuffer 828 * smallJson: push, set 829 * smallString: append, prepend, replace, intTo, insert, color, readFile 830 * 831 * The object is duplicated for: 832 * char * 833 * 834 * When self is an array which is an element of a smallArray, smallDict, the setP function in 835 * the parent object has to be called to update the sObject pointer (which is inside self). 836 * 837 * \param 838 * index: index in array, must be inside the array 839 * string 840 * \return 841 * 0 success 842 * -1 error 843 * 844 * Does nothing when: 845 * when array is NULL, index is not set correctly or s is NULL 846 */ 847 typedef smallArrayt* (*setAtSmallArrayFt) (smallArrayt *self, int64_t index, baset *value); 848 typedef smallArrayt* (*setAtUndefinedSmallArrayFt)(smallArrayt *self, int64_t index); 849 typedef smallArrayt* (*setAtBoolSmallArrayFt) (smallArrayt *self, int64_t index, bool value); 850 typedef smallArrayt* (*setAtDoubleSmallArrayFt) (smallArrayt *self, int64_t index, double value); 851 typedef smallArrayt* (*setAtIntSmallArrayFt) (smallArrayt *self, int64_t index, int64_t value); 852 typedef smallArrayt* (*setAtSSmallArrayFt) (smallArrayt *self, int64_t index, const char *string); 853 typedef smallArrayt* (*setAtCharSmallArrayFt) (smallArrayt *self, int64_t index, char c); 854 typedef smallArrayt* (*setAtDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *dict); 855 typedef smallArrayt* (*setAtArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *array); 856 typedef smallArrayt* (*setAtArraycSmallArrayFt) (smallArrayt *self, int64_t index, char **array); 857 typedef smallArrayt* (*setAtCArraycSmallArrayFt) (smallArrayt *self, int64_t index, const char **array); 858 typedef smallArrayt* (*setAtSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index, smallBoolt *value); 859 typedef smallArrayt* (*setAtSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index, smallBytest *value); 860 typedef smallArrayt* (*setAtSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index, smallDoublet *value); 861 typedef smallArrayt* (*setAtSmallIntSmallArrayFt) (smallArrayt *self, int64_t index, smallIntt *value); 862 typedef smallArrayt* (*setAtSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *value); 863 typedef smallArrayt* (*setAtSmallStringSmallArrayFt) (smallArrayt *self, int64_t index, smallStringt *string); 864 typedef smallArrayt* (*setAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container); 865 866 /** 867 * store object at given index (free already existing elements) 868 * index can be negative 869 * 870 * the object parameter is freed 871 * 872 * \param 873 * index: index in array, must be inside the array 874 * string 875 * \return 876 * 0 success 877 * -1 error 878 * 879 * Does nothing when: 880 * when array is NULL, index is not set correctly or s is NULL 881 */ 882 typedef smallArrayt* (*setAtNFreeSmallArrayFt) (smallArrayt *self, int64_t index, baset *value); 883 typedef smallArrayt* (*setAtNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined); 884 typedef smallArrayt* (*setAtNFreeSSmallArrayFt) (smallArrayt *self, int64_t index, char *string); 885 typedef smallArrayt* (*setAtNFreeDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *dict); 886 typedef smallArrayt* (*setAtNFreeArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *array); 887 typedef smallArrayt* (*setAtNFreeArraycSmallArrayFt) (smallArrayt *self, int64_t index, char **array); 888 typedef smallArrayt* (*setAtNFreeSmallBoolSmallArrayFt) (smallArrayt *self, int64_t index, smallBoolt *value); 889 typedef smallArrayt* (*setAtNFreeSmallBytesSmallArrayFt) (smallArrayt *self, int64_t index, smallBytest *value); 890 typedef smallArrayt* (*setAtNFreeSmallDoubleSmallArrayFt) (smallArrayt *self, int64_t index, smallDoublet *value); 891 typedef smallArrayt* (*setAtNFreeSmallIntSmallArrayFt) (smallArrayt *self, int64_t index, smallIntt *value); 892 typedef smallArrayt* (*setAtNFreeSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *value); 893 typedef smallArrayt* (*setAtNFreeSmallStringSmallArrayFt) (smallArrayt *self, int64_t index, smallStringt *string); 894 typedef smallArrayt* (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container); 895 896 /** 897 * store pointer at given index (existing element is not freed) 898 * index can be negative 899 * 900 * \param 901 * index: index in array, must be inside the array 902 * string 903 * \return 904 * 0 success 905 * -1 error 906 * 907 * Does nothing when: 908 * when array is NULL, index is not set correctly or s is NULL 909 */ 910 typedef smallArrayt* (*setPAtArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *array); 911 typedef smallArrayt* (*setPAtDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *dict); 912 typedef smallArrayt* (*setPAtSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *json); 913 typedef smallArrayt* (*setPAtSmallStringSmallArrayFt) (smallArrayt *self, int64_t index, smallStringt *string); 914 typedef smallArrayt* (*setPAtNFreeArraySmallArrayFt) (smallArrayt *self, int64_t index, smallArrayt *array); 915 typedef smallArrayt* (*setPAtNFreeDictSmallArrayFt) (smallArrayt *self, int64_t index, smallDictt *dict); 916 typedef smallArrayt* (*setPAtNFreeSmallJsonSmallArrayFt) (smallArrayt *self, int64_t index, smallJsont *json); 917 typedef smallArrayt* (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index, smallStringt *string); 918 919 /** 920 * get number 921 * 922 * if the element is a double, its value is returned as is 923 * if the element is an int, its value is converted to double 924 * if the element is not a number, 0 is returned 925 * 926 * \param 927 * index in array 928 * \return 929 * double type number or 0 930 */ 931 typedef double (*getNumSmallArrayFt) (smallArrayt *self, int64_t index); 932 933 /** 934 * check if self has object 935 * 936 * \param 937 * object to find 938 * \return 939 * true when the object is found 940 */ 941 typedef bool (*hasSmallArrayFt) (smallArrayt *self, baset *value); 942 typedef bool (*hasUndefinedSmallArrayFt)(smallArrayt *self, undefinedt *undefined); 943 typedef bool (*hasBoolSmallArrayFt) (smallArrayt *self, bool value); 944 typedef bool (*hasDoubleSmallArrayFt) (smallArrayt *self, double value); 945 typedef bool (*hasIntSmallArrayFt) (smallArrayt *self, int64_t value); 946 typedef bool (*hasSSmallArrayFt) (smallArrayt *self, const char *string); 947 typedef bool (*hasCharSmallArrayFt) (smallArrayt *self, char c); 948 typedef bool (*hasDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 949 typedef bool (*hasArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 950 typedef bool (*hasArraycSmallArrayFt) (smallArrayt *self, char **array); 951 typedef bool (*hasCArraycSmallArrayFt) (smallArrayt *self, const char **array); 952 typedef bool (*hasSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 953 typedef bool (*hasSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 954 typedef bool (*hasSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 955 typedef bool (*hasSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 956 typedef bool (*hasSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 957 typedef bool (*hasSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 958 typedef bool (*hasSmallContainerSmallArrayFt)(smallArrayt *self, smallContainert *container); 959 960 /** 961 * return index of object in list 962 * 963 * \param 964 * value 965 * \return 966 * index 967 * -1 when the value is not found 968 * -1 when array or value are NULL 969 */ 970 typedef ssize_t (*indexOfSmallArrayFt) (smallArrayt *self, baset *value); 971 typedef ssize_t (*indexOfUndefinedSmallArrayFt)(smallArrayt *self, undefinedt *undefined); 972 typedef ssize_t (*indexOfBoolSmallArrayFt) (smallArrayt *self, bool value); 973 typedef ssize_t (*indexOfDoubleSmallArrayFt) (smallArrayt *self, double value); 974 typedef ssize_t (*indexOfIntSmallArrayFt) (smallArrayt *self, int64_t value); 975 typedef ssize_t (*indexOfSSmallArrayFt) (smallArrayt *self, const char *string); 976 typedef ssize_t (*indexOfCharSmallArrayFt) (smallArrayt *self, char c); 977 typedef ssize_t (*indexOfDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 978 typedef ssize_t (*indexOfArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 979 typedef ssize_t (*indexOfArraycSmallArrayFt) (smallArrayt *self, char **array); 980 typedef ssize_t (*indexOfCArraycSmallArrayFt) (smallArrayt *self, const char **array); 981 typedef ssize_t (*indexOfSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 982 typedef ssize_t (*indexOfSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 983 typedef ssize_t (*indexOfSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 984 typedef ssize_t (*indexOfSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 985 typedef ssize_t (*indexOfSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 986 typedef ssize_t (*indexOfSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 987 typedef ssize_t (*indexOfSmallContainerSmallArrayFt)(smallArrayt *self, smallContainert *container); 988 989 /** 990 * efficiently finds the index of object in list 991 * the list has be sorted with the sort function 992 * 993 * \param 994 * value to search 995 * \return 996 * index of value 997 * -1 value not found or NULL input pointers 998 */ 999 typedef ssize_t (*binarySearchSmallArrayFt) (smallArrayt *self, baset *value); 1000 typedef ssize_t (*binarySearchUndefinedSmallArrayFt)(smallArrayt *self, undefinedt *undefined); 1001 typedef ssize_t (*binarySearchBoolSmallArrayFt) (smallArrayt *self, bool value); 1002 typedef ssize_t (*binarySearchDoubleSmallArrayFt) (smallArrayt *self, double value); 1003 typedef ssize_t (*binarySearchIntSmallArrayFt) (smallArrayt *self, int64_t value); 1004 typedef ssize_t (*binarySearchSSmallArrayFt) (smallArrayt *self, const char *string); 1005 typedef ssize_t (*binarySearchCharSmallArrayFt) (smallArrayt *self, char c); 1006 typedef ssize_t (*binarySearchDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 1007 typedef ssize_t (*binarySearchArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 1008 typedef ssize_t (*binarySearchArraycSmallArrayFt) (smallArrayt *self, char **array); 1009 typedef ssize_t (*binarySearchCArraycSmallArrayFt) (smallArrayt *self, const char **array); 1010 typedef ssize_t (*binarySearchSmallBoolSmallArrayFt) (smallArrayt *self, smallBoolt *value); 1011 typedef ssize_t (*binarySearchSmallBytesSmallArrayFt) (smallArrayt *self, smallBytest *value); 1012 typedef ssize_t (*binarySearchSmallDoubleSmallArrayFt) (smallArrayt *self, smallDoublet *value); 1013 typedef ssize_t (*binarySearchSmallIntSmallArrayFt) (smallArrayt *self, smallIntt *value); 1014 typedef ssize_t (*binarySearchSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 1015 typedef ssize_t (*binarySearchSmallStringSmallArrayFt) (smallArrayt *self, smallStringt *string); 1016 typedef ssize_t (*binarySearchSmallContainerSmallArrayFt)(smallArrayt *self, smallContainert *container); 1017 1018 /** 1019 * Uniquify elements of list 1020 * each elements are unique in self 1021 * 1022 * \return 1023 * self with unique elements 1024 * empty list when list is empty 1025 * 0 success 1026 * -1 error 1027 */ 1028 typedef smallArrayt* (*uniqSmallArrayFt) (smallArrayt *self); 1029 1030 /** 1031 * ignore case and check if self has object 1032 * 1033 * \param 1034 * object to find 1035 * \return 1036 * true when the object is found 1037 */ 1038 typedef bool (*icHasSmallArrayFt) (smallArrayt *self, baset *value); 1039 typedef bool (*icHasSSmallArrayFt) (smallArrayt *self, const char *string); 1040 typedef bool (*icHasCharSmallArrayFt) (smallArrayt *self, char c); 1041 typedef bool (*icHasDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 1042 typedef bool (*icHasArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 1043 typedef bool (*icHasArraycSmallArrayFt) (smallArrayt *self, char **array); 1044 typedef bool (*icHasCArraycSmallArrayFt) (smallArrayt *self, const char **array); 1045 typedef bool (*icHasSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 1046 typedef bool (*icHasSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *string); 1047 1048 /** 1049 * ignore case and return index of object in list 1050 * 1051 * \param 1052 * value 1053 * \return 1054 * index 1055 * -1 when the value is not found 1056 * -1 when array or value are NULL 1057 */ 1058 typedef ssize_t (*icIndexOfSmallArrayFt) (smallArrayt *self, baset *value); 1059 typedef ssize_t (*icIndexOfSSmallArrayFt) (smallArrayt *self, const char *string); 1060 typedef ssize_t (*icIndexOfCharSmallArrayFt) (smallArrayt *self, char c); 1061 typedef ssize_t (*icIndexOfDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 1062 typedef ssize_t (*icIndexOfArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 1063 typedef ssize_t (*icIndexOfArraycSmallArrayFt) (smallArrayt *self, char **array); 1064 typedef ssize_t (*icIndexOfCArraycSmallArrayFt) (smallArrayt *self, const char **array); 1065 typedef ssize_t (*icIndexOfSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 1066 typedef ssize_t (*icIndexOfSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *string); 1067 1068 /** 1069 * ignore case and efficiently finds the index of object in list 1070 * the list has be sorted with the sort function 1071 * 1072 * \param 1073 * value to search 1074 * \return 1075 * index of value 1076 * -1 value not found or NULL input pointers 1077 */ 1078 typedef ssize_t (*icBinarySearchSmallArrayFt) (smallArrayt *self, baset *value); 1079 typedef ssize_t (*icBinarySearchSSmallArrayFt) (smallArrayt *self, const char *string); 1080 typedef ssize_t (*icBinarySearchCharSmallArrayFt) (smallArrayt *self, char c); 1081 typedef ssize_t (*icBinarySearchDictSmallArrayFt) (smallArrayt *self, smallDictt *dict); 1082 typedef ssize_t (*icBinarySearchArraySmallArrayFt) (smallArrayt *self, smallArrayt *array); 1083 typedef ssize_t (*icBinarySearchArraycSmallArrayFt) (smallArrayt *self, char **array); 1084 typedef ssize_t (*icBinarySearchCArraycSmallArrayFt) (smallArrayt *self, const char **array); 1085 typedef ssize_t (*icBinarySearchSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *string); 1086 typedef ssize_t (*icBinarySearchSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *string); 1087 1088 /** 1089 * ignore case and uniquify elements of list 1090 * each elements are unique in self 1091 * 1092 * \return 1093 * self with unique elements 1094 * empty list when list is empty 1095 * 0 success 1096 * -1 error 1097 */ 1098 typedef smallArrayt* (*icUniqSmallArrayFt) (smallArrayt *self); 1099 1100 /** 1101 * remove empty elements from self 1102 * 1103 * \return 1104 * list without empty elements 1105 * empty list when list is empty 1106 * 0 success 1107 * -1 error 1108 */ 1109 typedef smallArrayt* (*compactSmallArrayFt) (smallArrayt *self); 1110 1111 /** 1112 * free elements and index 1113 */ 1114 typedef smallArrayt* (*emptySmallArrayFt) (smallArrayt *self); 1115 1116 /** 1117 * \return 1118 * true when self is empty (len=0) 1119 * false when len > 0 1120 */ 1121 typedef bool (*isEmptySmallArrayFt) (smallArrayt *self); 1122 1123 /** 1124 * \return 1125 * true when all elements in self are blank 1126 * false when there is non blank element 1127 */ 1128 typedef bool (*isBlankSmallArrayFt) (smallArrayt *self); 1129 1130 /** 1131 * user defined function called in the forEach loop 1132 * this fucntion is a parameter to the forEach function 1133 * 1134 * \param 1135 * closure user defined pointer 1136 * \param 1137 * index index for element 1138 * \param 1139 * element element at index 1140 * \return 1141 * true to continue the loop 1142 * false to break the loop 1143 */ 1144 typedef bool (*forEachElementSmallArrayFt) (void *closure, baset *element); 1145 1146 /** 1147 * for each loop on elements in the Array 1148 * 1149 * \param 1150 * closure user defined pointer 1151 * \param 1152 * funcElem user defined function call on each element 1153 */ 1154 typedef void (*forEachSmallArrayFt) (smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem); 1155 1156 /** 1157 * user defined function called in the enumerate loop 1158 * this fucntion is a parameter to the enumerate function 1159 * 1160 * \param 1161 * closure user defined pointer 1162 * \param 1163 * index index for element 1164 * \param 1165 * element element at index 1166 * \return 1167 * true to continue the loop 1168 * false to break the loop 1169 */ 1170 typedef bool (*enumerateElementSmallArrayFt) (void *closure, size_t index, baset *element); 1171 1172 /** 1173 * enumerate elements in the Array 1174 * 1175 * \param 1176 * closure user defined pointer 1177 * \param 1178 * funcElem user defined function call on each element 1179 */ 1180 typedef void (*enumerateSmallArrayFt) (smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem); 1181 1182 1183 /** 1184 * iterator 1185 * 1186 * iterStart resets and starts the iteration 1187 * use iterIndex method to get current index 1188 * 1189 * index and step can be negative (python index) 1190 * 1191 * Example: 1192 * iter(array, e) { 1193 * logVarG(e); 1194 * } 1195 */ 1196 typedef baset* (*iterStartSmallArrayFt) (smallArrayt *self); 1197 typedef baset* (*iterStartLastSmallArrayFt) (smallArrayt *self); 1198 typedef baset* (*iterStartFromSmallArrayFt) (smallArrayt *self, int64_t index); 1199 typedef baset* (*iterStartFromStepSmallArrayFt) (smallArrayt *self, int64_t index, int64_t step); 1200 typedef baset* (*iterNextSmallArrayFt) (smallArrayt *self); 1201 typedef baset* (*iterElementSmallArrayFt) (smallArrayt *self); 1202 typedef ssize_t (*iterIndexSmallArrayFt) (smallArrayt *self); 1203 typedef int64_t (*iterStepSmallArrayFt) (smallArrayt *self); 1204 1205 /** 1206 * join list, the elements are seperated with delim in the resulting string 1207 * 1208 * \param 1209 * delim: string seperator 1210 * \return 1211 * joined string 1212 * NULL when list or delim are NULL 1213 */ 1214 typedef smallStringt* (*joinSmallArrayFt) (smallArrayt *self, const char* delim); 1215 typedef smallStringt* (*joinCharSmallArrayFt) (smallArrayt *self, char c); 1216 typedef smallStringt* (*joinSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont* delim); 1217 typedef smallStringt* (*joinSmallStringSmallArrayFt)(smallArrayt *self, smallStringt* delim); 1218 1219 /** 1220 * join list, the elements are seperated with delim in the resulting string 1221 * 1222 * \param 1223 * delim: string seperator 1224 * \return 1225 * joined string 1226 * NULL when list or delim are NULL 1227 */ 1228 typedef char* (*joinSSmallArrayFt) (smallArrayt *self, const char* delim); 1229 typedef char* (*joinCharSSmallArrayFt) (smallArrayt *self, char c); 1230 typedef char* (*joinSmallJsonSSmallArrayFt) (smallArrayt *self, smallJsont* delim); 1231 typedef char* (*joinSmallStringSSmallArrayFt)(smallArrayt *self, smallStringt* delim); 1232 1233 /** 1234 * zip arrays and store in array 1235 * 1236 * \return 1237 * self all the elements from keys and values are in the array 1238 * (some elements from keys and values are in the array or keys or values length is 0) 1239 * NULL keys or values is NULL 1240 */ 1241 typedef smallArrayt* (*zipSmallArrayFt) (smallArrayt *self, smallArrayt *array1, smallArrayt *array2); 1242 typedef smallArrayt* (*zipSmallJsonSmallArrayFt) (smallArrayt *self, smallArrayt *array1, smallJsont *array2); 1243 typedef smallArrayt* (*zipSmallJsonSmallArraySmallArrayFt)(smallArrayt *self, smallJsont *array1, smallArrayt *array2); 1244 typedef smallArrayt* (*zipSmallJsonSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *array1, smallJsont *array2); 1245 typedef smallArrayt* (*zipSmallJsonCharSmallArrayFt) (smallArrayt *self, smallJsont *array1, char **array2); 1246 typedef smallArrayt* (*zipSmallJsonCCharSmallArrayFt) (smallArrayt *self, smallJsont *array1, const char **array2); 1247 typedef smallArrayt* (*zipArraySmallArrayFt) (smallArrayt *self, char** array1, smallArrayt *array2); 1248 typedef smallArrayt* (*zipCArraySmallArrayFt) (smallArrayt *self, const char** array1, smallArrayt *array2); 1249 typedef smallArrayt* (*zipArraySmallJsonSmallArrayFt) (smallArrayt *self, char** array1, smallJsont *array2); 1250 typedef smallArrayt* (*zipCArraySmallJsonSmallArrayFt) (smallArrayt *self, const char** array1, smallJsont *array2); 1251 typedef smallArrayt* (*zipCharSmallArrayFt) (smallArrayt *self, smallArrayt *array1, char** array2); 1252 typedef smallArrayt* (*zipCCharSmallArrayFt) (smallArrayt *self, smallArrayt *array1, const char** array2); 1253 typedef smallArrayt* (*zipArrayCharSmallArrayFt) (smallArrayt *self, char** array1, char** array2); 1254 typedef smallArrayt* (*zipCArrayCharSmallArrayFt) (smallArrayt *self, const char** array1, char** array2); 1255 typedef smallArrayt* (*zipArrayCCharSmallArrayFt) (smallArrayt *self, char** array1, const char** array2); 1256 typedef smallArrayt* (*zipCArrayCCharSmallArrayFt) (smallArrayt *self, const char** array1, const char** array2); 1257 1258 /** 1259 * print list elements, one line per element 1260 * to stdout 1261 * 1262 * when list is NULL, returns directly without doing anything 1263 * 1264 * \return 1265 * nothing 1266 */ 1267 typedef void (*logSmallArrayFt) (smallArrayt *self); 1268 1269 /** 1270 * read text from filePath to self 1271 * new line characters are removed 1272 * 1273 * \param 1274 * filePath: file path 1275 * \return 1276 * lines in list 1277 * empty list when the file is empty 1278 * -1 on failure 1279 */ 1280 typedef smallArrayt* (*readTextSmallArrayFt) (smallArrayt *self, const char *filePath); 1281 typedef smallArrayt* (*readTextSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *filePath); 1282 typedef smallArrayt* (*readTextSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *filePath); 1283 1284 /** 1285 * return text from stream fp in a list 1286 * new line characters are removed 1287 * 1288 * \param 1289 * fp: file stream 1290 * \return 1291 * lines in list 1292 * empty list when there is no data in the stream 1293 * NULL on failure 1294 */ 1295 typedef smallArrayt* (*readStreamSmallArrayFt) (smallArrayt *self, FILE *fp); 1296 1297 /** 1298 * write array to filePath 1299 * 1300 * \param 1301 * filePath 1302 * \return 1303 * true success 1304 * false failed, filePath or list are NULL 1305 */ 1306 typedef bool (*writeTextSmallArrayFt) (smallArrayt *self, const char *filePath); 1307 typedef bool (*writeTextSmallJsonSmallArrayFt) (smallArrayt *self, smallJsont *filePath); 1308 typedef bool (*writeTextSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *filePath); 1309 1310 /** 1311 * write list to stream 1312 * 1313 * \param 1314 * fp: file stream 1315 * list 1316 * \return 1317 * true success 1318 * false failed, fp or list are NULL 1319 */ 1320 typedef bool (*writeStreamSmallArrayFt) (smallArrayt *self, FILE *fp); 1321 1322 /** 1323 * append list to filePath 1324 * 1325 * \param 1326 * filePath 1327 * list 1328 * \return 1329 * true success 1330 * false failed, filePath or list are NULL 1331 */ 1332 typedef bool (*appendTextSmallArrayFt) (smallArrayt *self, const char *filePath); 1333 typedef bool (*appendTextSmallStringSmallArrayFt)(smallArrayt *self, smallStringt *filePath); 1334 1335 /** 1336 * get object type string at index 1337 * 1338 * \param 1339 * index in array 1340 * \return 1341 * object type string 1342 */ 1343 typedef const char* (*typeStringSmallArrayFt) (smallArrayt *self, int64_t index); 1344 typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index); 1345 1346 /** 1347 * get object type at index 1348 * 1349 * \param 1350 * index in array 1351 * \return 1352 * object type 1353 */ 1354 typedef char (*typeSmallArrayFt) (smallArrayt *self, int64_t index); 1355 1356 /** 1357 * get first level of object type string in array 1358 * 1359 * \return 1360 * list of object type strings 1361 */ 1362 typedef const char** (*typeStringsSmallArrayFt)(smallArrayt *self); 1363 typedef smallArrayt* (*typeSmallStringsSmallArrayFt)(smallArrayt *self); 1364 1365 /** 1366 * get first level of object type in array 1367 * 1368 * \return 1369 * smallBytes list of object type 1370 */ 1371 typedef smallBytest* (*typesSmallArrayFt) (smallArrayt *self); 1372 1373 /** 1374 * is element at index of type type 1375 */ 1376 typedef bool (*isETypeSmallArrayFt) (smallArrayt *self, int64_t index, const char *type); 1377 typedef bool (*isEUndefinedSmallArrayFt) (smallArrayt *self, int64_t index); 1378 typedef bool (*isEBoolSmallArrayFt) (smallArrayt *self, int64_t index); 1379 typedef bool (*isEContainerSmallArrayFt) (smallArrayt *self, int64_t index); 1380 typedef bool (*isEDictSmallArrayFt) (smallArrayt *self, int64_t index); 1381 typedef bool (*isEDoubleSmallArrayFt) (smallArrayt *self, int64_t index); 1382 typedef bool (*isEIntSmallArrayFt) (smallArrayt *self, int64_t index); 1383 typedef bool (*isEStringSmallArrayFt) (smallArrayt *self, int64_t index); 1384 typedef bool (*isEFaststringSmallArrayFt)(smallArrayt *self, int64_t index); 1385 typedef bool (*isEArraySmallArrayFt) (smallArrayt *self, int64_t index); 1386 typedef bool (*isEBytesSmallArrayFt) (smallArrayt *self, int64_t index); 1387 1388 /** 1389 * are all elements of type type 1390 */ 1391 typedef bool (*areAllETypeSmallArrayFt) (smallArrayt *self, const char *type); 1392 typedef bool (*areAllEUndefinedSmallArrayFt) (smallArrayt *self); 1393 typedef bool (*areAllEBoolSmallArrayFt) (smallArrayt *self); 1394 typedef bool (*areAllEContainerSmallArrayFt) (smallArrayt *self); 1395 typedef bool (*areAllEDictSmallArrayFt) (smallArrayt *self); 1396 typedef bool (*areAllEDoubleSmallArrayFt) (smallArrayt *self); 1397 typedef bool (*areAllEIntSmallArrayFt) (smallArrayt *self); 1398 typedef bool (*areAllEStringSmallArrayFt) (smallArrayt *self); 1399 typedef bool (*areAllEFaststringSmallArrayFt)(smallArrayt *self); 1400 typedef bool (*areAllEArraySmallArrayFt) (smallArrayt *self); 1401 typedef bool (*areAllEBytesSmallArrayFt) (smallArrayt *self); 1402 1403 /** 1404 * class functions 1405 * allocated once for all objects 1406 * 1407 * freed with finalizeSmallArray or finalizeLibsheepy 1408 */ 1409 1410 /** 1411 * use this define in child classes and add the new function after this class functions 1412 * 1413 * Example: 1414 * #define RINGFUNCTIONST \ 1415 * SMALLARRAYFUNCTIONST; \ 1416 * setSizeRingFt setSize 1417 */ 1418 #define SMALLARRAYFUNCTIONST \ 1419 escapeSmallArrayFt escape;\ 1420 disposeSmallArrayFt dispose;\ 1421 helpSmallArrayFt help;\ 1422 resetSmallArrayFt reset;\ 1423 getsoSmallArrayFt getso;\ 1424 setsoSmallArrayFt setso;\ 1425 mirrorSmallArrayFt mirror;\ 1426 getAtSmallArrayFt get;\ 1427 getAtNDupSmallArrayFt getNDup;\ 1428 setAtSmallArrayFt set;\ 1429 fromArraySmallArrayFt fromArray;\ 1430 fromCArraySmallArrayFt fromCArray;\ 1431 fromArrayNFreeSmallArrayFt fromArrayNFree;\ 1432 pushSmallArrayFt push;\ 1433 pushUndefinedSmallArrayFt pushUndefined;\ 1434 pushBoolSmallArrayFt pushBool;\ 1435 pushDoubleSmallArrayFt pushDouble;\ 1436 pushIntSmallArrayFt pushInt;\ 1437 pushSSmallArrayFt pushS;\ 1438 pushCharSmallArrayFt pushChar;\ 1439 pushDictSmallArrayFt pushDict;\ 1440 pushArraySmallArrayFt pushArray;\ 1441 pushArraycSmallArrayFt pushArrayc;\ 1442 pushCArraycSmallArrayFt pushCArrayc;\ 1443 pushSmallBoolSmallArrayFt pushSmallBool;\ 1444 pushSmallBytesSmallArrayFt pushSmallBytes;\ 1445 pushSmallDoubleSmallArrayFt pushSmallDouble;\ 1446 pushSmallIntSmallArrayFt pushSmallInt;\ 1447 pushSmallJsonSmallArrayFt pushSmallJson;\ 1448 pushSmallStringSmallArrayFt pushSmallString;\ 1449 pushSmallContainerSmallArrayFt pushSmallContainer;\ 1450 pushNFreeSmallArrayFt pushNFree;\ 1451 pushNFreeUndefinedSmallArrayFt pushNFreeUndefined;\ 1452 pushNFreeSSmallArrayFt pushNFreeS;\ 1453 pushNFreeDictSmallArrayFt pushNFreeDict;\ 1454 pushNFreeArraySmallArrayFt pushNFreeArray;\ 1455 pushNFreeArraycSmallArrayFt pushNFreeArrayc;\ 1456 pushNFreeSmallBoolSmallArrayFt pushNFreeSmallBool;\ 1457 pushNFreeSmallBytesSmallArrayFt pushNFreeSmallBytes;\ 1458 pushNFreeSmallDoubleSmallArrayFt pushNFreeSmallDouble;\ 1459 pushNFreeSmallIntSmallArrayFt pushNFreeSmallInt;\ 1460 pushNFreeSmallJsonSmallArrayFt pushNFreeSmallJson;\ 1461 pushNFreeSmallStringSmallArrayFt pushNFreeSmallString;\ 1462 pushNFreeSmallContainerSmallArrayFt pushNFreeSmallContainer;\ 1463 pushManySmallArrayFt pushMany;\ 1464 pushManySSmallArrayFt pushManyS;\ 1465 pushNFreeManySmallArrayFt pushNFreeMany;\ 1466 pushNFreeManySSmallArrayFt pushNFreeManyS;\ 1467 popSmallArrayFt pop;\ 1468 popUndefinedSmallArrayFt popUndefined;\ 1469 popBoolSmallArrayFt popBool;\ 1470 popDoubleSmallArrayFt popDouble;\ 1471 popIntSmallArrayFt popInt;\ 1472 popInt32SmallArrayFt popInt32;\ 1473 popUintSmallArrayFt popUint;\ 1474 popUint32SmallArrayFt popUint32;\ 1475 popSSmallArrayFt popS;\ 1476 popDictSmallArrayFt popDict;\ 1477 popArraySmallArrayFt popArray;\ 1478 popSmallBoolSmallArrayFt popSmallBool;\ 1479 popSmallBytesSmallArrayFt popSmallBytes;\ 1480 popSmallDoubleSmallArrayFt popSmallDouble;\ 1481 popSmallIntSmallArrayFt popSmallInt;\ 1482 popSmallJsonSmallArrayFt popSmallJson;\ 1483 popSmallStringSmallArrayFt popSmallString;\ 1484 popVoidSmallArrayFt popVoid;\ 1485 popSmallContainerSmallArrayFt popSmallContainer;\ 1486 popNumSmallArrayFt popNum;\ 1487 prependSmallArrayFt prepend;\ 1488 prependUndefinedSmallArrayFt prependUndefined;\ 1489 prependBoolSmallArrayFt prependBool;\ 1490 prependDoubleSmallArrayFt prependDouble;\ 1491 prependIntSmallArrayFt prependInt;\ 1492 prependSSmallArrayFt prependS;\ 1493 prependCharSmallArrayFt prependChar;\ 1494 prependDictSmallArrayFt prependDict;\ 1495 prependArraySmallArrayFt prependArray;\ 1496 prependArraycSmallArrayFt prependArrayc;\ 1497 prependCArraycSmallArrayFt prependCArrayc;\ 1498 prependSmallBoolSmallArrayFt prependSmallBool;\ 1499 prependSmallBytesSmallArrayFt prependSmallBytes;\ 1500 prependSmallDoubleSmallArrayFt prependSmallDouble;\ 1501 prependSmallIntSmallArrayFt prependSmallInt;\ 1502 prependSmallJsonSmallArrayFt prependSmallJson;\ 1503 prependSmallStringSmallArrayFt prependSmallString;\ 1504 prependSmallContainerSmallArrayFt prependSmallContainer;\ 1505 prependNFreeSmallArrayFt prependNFree;\ 1506 prependNFreeUndefinedSmallArrayFt prependNFreeUndefined;\ 1507 prependNFreeSSmallArrayFt prependNFreeS;\ 1508 prependNFreeDictSmallArrayFt prependNFreeDict;\ 1509 prependNFreeArraySmallArrayFt prependNFreeArray;\ 1510 prependNFreeArraycSmallArrayFt prependNFreeArrayc;\ 1511 prependNFreeSmallBoolSmallArrayFt prependNFreeSmallBool;\ 1512 prependNFreeSmallBytesSmallArrayFt prependNFreeSmallBytes;\ 1513 prependNFreeSmallDoubleSmallArrayFt prependNFreeSmallDouble;\ 1514 prependNFreeSmallIntSmallArrayFt prependNFreeSmallInt;\ 1515 prependNFreeSmallJsonSmallArrayFt prependNFreeSmallJson;\ 1516 prependNFreeSmallStringSmallArrayFt prependNFreeSmallString;\ 1517 prependNFreeSmallContainerSmallArrayFt prependNFreeSmallContainer;\ 1518 dequeueSmallArrayFt dequeue;\ 1519 dequeueUndefinedSmallArrayFt dequeueUndefined;\ 1520 dequeueBoolSmallArrayFt dequeueBool;\ 1521 dequeueDoubleSmallArrayFt dequeueDouble;\ 1522 dequeueIntSmallArrayFt dequeueInt;\ 1523 dequeueInt32SmallArrayFt dequeueInt32;\ 1524 dequeueUintSmallArrayFt dequeueUint;\ 1525 dequeueUint32SmallArrayFt dequeueUint32;\ 1526 dequeueSSmallArrayFt dequeueS;\ 1527 dequeueDictSmallArrayFt dequeueDict;\ 1528 dequeueArraySmallArrayFt dequeueArray;\ 1529 dequeueSmallBoolSmallArrayFt dequeueSmallBool;\ 1530 dequeueSmallBytesSmallArrayFt dequeueSmallBytes;\ 1531 dequeueSmallDoubleSmallArrayFt dequeueSmallDouble;\ 1532 dequeueSmallIntSmallArrayFt dequeueSmallInt;\ 1533 dequeueSmallJsonSmallArrayFt dequeueSmallJson;\ 1534 dequeueSmallStringSmallArrayFt dequeueSmallString;\ 1535 dequeueVoidSmallArrayFt dequeueVoid;\ 1536 dequeueSmallContainerSmallArrayFt dequeueSmallContainer;\ 1537 dequeueNumSmallArrayFt dequeueNum;\ 1538 reverseSmallArrayFt reverse;\ 1539 catSmallArrayFt cat;\ 1540 appendSmallArrayFt append;\ 1541 appendSmallJsonSmallArrayFt appendSmallJson;\ 1542 appendNSmashSmallArrayFt appendNSmash;\ 1543 appendNSmashSmallJsonSmallArrayFt appendNSmashSmallJson;\ 1544 appendArraySmallArrayFt appendArray;\ 1545 appendCArraySmallArrayFt appendCArray;\ 1546 appendNSmashArraySmallArrayFt appendNSmashArray;\ 1547 shiftSmallArrayFt shift;\ 1548 shiftSmallJsonSmallArrayFt shiftSmallJson;\ 1549 shiftNSmashSmallArrayFt shiftNSmash;\ 1550 shiftNSmashSmallJsonSmallArrayFt shiftNSmashSmallJson;\ 1551 addSmallArrayFt add;\ 1552 sliceSmallArrayFt slice;\ 1553 cropSmallArrayFt crop;\ 1554 cropElemSmallArrayFt cropElem;\ 1555 cropElemUndefinedSmallArrayFt cropElemUndefined;\ 1556 cropElemBoolSmallArrayFt cropElemBool;\ 1557 cropElemDoubleSmallArrayFt cropElemDouble;\ 1558 cropElemIntSmallArrayFt cropElemInt;\ 1559 cropElemInt32SmallArrayFt cropElemInt32;\ 1560 cropElemUintSmallArrayFt cropElemUint;\ 1561 cropElemUint32SmallArrayFt cropElemUint32;\ 1562 cropElemSSmallArrayFt cropElemS;\ 1563 cropElemDictSmallArrayFt cropElemDict;\ 1564 cropElemArraySmallArrayFt cropElemArray;\ 1565 cropElemSmallBoolSmallArrayFt cropElemSmallBool;\ 1566 cropElemSmallBytesSmallArrayFt cropElemSmallBytes;\ 1567 cropElemSmallDoubleSmallArrayFt cropElemSmallDouble;\ 1568 cropElemSmallIntSmallArrayFt cropElemSmallInt;\ 1569 cropElemSmallJsonSmallArrayFt cropElemSmallJson;\ 1570 cropElemSmallStringSmallArrayFt cropElemSmallString;\ 1571 cropElemVoidSmallArrayFt cropElemVoid;\ 1572 cropElemSmallContainerSmallArrayFt cropElemSmallContainer;\ 1573 copySmallArrayFt copy;\ 1574 insertSmallArrayFt insert;\ 1575 insertSmallJsonSmallArrayFt insertSmallJson;\ 1576 insertNSmashSmallArrayFt insertNSmash;\ 1577 insertNSmashSmallJsonSmallArrayFt insertNSmashSmallJson;\ 1578 injectSmallArrayFt inject;\ 1579 injectUndefinedSmallArrayFt injectUndefined;\ 1580 injectBoolSmallArrayFt injectBool;\ 1581 injectDoubleSmallArrayFt injectDouble;\ 1582 injectIntSmallArrayFt injectInt;\ 1583 injectSSmallArrayFt injectS;\ 1584 injectCharSmallArrayFt injectChar;\ 1585 injectDictSmallArrayFt injectDict;\ 1586 injectArraySmallArrayFt injectArray;\ 1587 injectArraycSmallArrayFt injectArrayc;\ 1588 injectCArraycSmallArrayFt injectCArrayc;\ 1589 injectSmallBoolSmallArrayFt injectSmallBool;\ 1590 injectSmallBytesSmallArrayFt injectSmallBytes;\ 1591 injectSmallDoubleSmallArrayFt injectSmallDouble;\ 1592 injectSmallIntSmallArrayFt injectSmallInt;\ 1593 injectSmallJsonSmallArrayFt injectSmallJson;\ 1594 injectSmallStringSmallArrayFt injectSmallString;\ 1595 injectSmallContainerSmallArrayFt injectSmallContainer;\ 1596 injectNFreeSmallArrayFt injectNFree;\ 1597 injectNFreeUndefinedSmallArrayFt injectNFreeUndefined;\ 1598 injectNFreeSSmallArrayFt injectNFreeS;\ 1599 injectNFreeDictSmallArrayFt injectNFreeDict;\ 1600 injectNFreeArraySmallArrayFt injectNFreeArray;\ 1601 injectNFreeArraycSmallArrayFt injectNFreeArrayc;\ 1602 injectNFreeSmallBoolSmallArrayFt injectNFreeSmallBool;\ 1603 injectNFreeSmallBytesSmallArrayFt injectNFreeSmallBytes;\ 1604 injectNFreeSmallDoubleSmallArrayFt injectNFreeSmallDouble;\ 1605 injectNFreeSmallIntSmallArrayFt injectNFreeSmallInt;\ 1606 injectNFreeSmallJsonSmallArrayFt injectNFreeSmallJson;\ 1607 injectNFreeSmallStringSmallArrayFt injectNFreeSmallString;\ 1608 injectNFreeSmallContainerSmallArrayFt injectNFreeSmallContainer;\ 1609 delSmallArrayFt del;\ 1610 delElemSmallArrayFt delElem;\ 1611 removeSmallArrayFt remove;\ 1612 removeElemSmallArrayFt removeElem;\ 1613 sortSmallArrayFt sort;\ 1614 sortFSmallArrayFt sortF;\ 1615 icSortSmallArrayFt icSort;\ 1616 equalSmallArrayFt equal;\ 1617 equalSmallArraySmallJsonFt equalSmallJson;\ 1618 equalSmallArrayArrayFt equalArray;\ 1619 equalSmallArrayCArrayFt equalCArray;\ 1620 equalSmallArrayBaseFt equalBase;\ 1621 icEqualSmallArrayFt icEqual;\ 1622 icEqualSmallArraySmallJsonFt icEqualSmallJson;\ 1623 icEqualSmallArrayArrayFt icEqualArray;\ 1624 icEqualSmallArrayCArrayFt icEqualCArray;\ 1625 icEqualSmallArrayBaseFt icEqualBase;\ 1626 lenSmallArrayFt len;\ 1627 trimSmallArrayFt trim;\ 1628 getAtSmallArrayFt getAt;\ 1629 getAtUndefinedSmallArrayFt getAtUndefined;\ 1630 getAtBoolSmallArrayFt getAtBool;\ 1631 getAtBoolPSmallArrayFt getAtBoolP;\ 1632 getAtDoubleSmallArrayFt getAtDouble;\ 1633 getAtDoublePSmallArrayFt getAtDoubleP;\ 1634 getAtIntSmallArrayFt getAtInt;\ 1635 getAtIntPSmallArrayFt getAtIntP;\ 1636 getAtInt32SmallArrayFt getAtInt32;\ 1637 getAtInt32PSmallArrayFt getAtInt32P;\ 1638 getAtUintSmallArrayFt getAtUint;\ 1639 getAtUintPSmallArrayFt getAtUintP;\ 1640 getAtUint32SmallArrayFt getAtUint32;\ 1641 getAtUint32PSmallArrayFt getAtUint32P;\ 1642 getAtSSmallArrayFt getAtS;\ 1643 getAtDictSmallArrayFt getAtDict;\ 1644 getAtArraySmallArrayFt getAtArray;\ 1645 getAtSmallBoolSmallArrayFt getAtSmallBool;\ 1646 getAtSmallBytesSmallArrayFt getAtSmallBytes;\ 1647 getAtSmallDoubleSmallArrayFt getAtSmallDouble;\ 1648 getAtSmallIntSmallArrayFt getAtSmallInt;\ 1649 getAtSmallJsonSmallArrayFt getAtSmallJson;\ 1650 getAtSmallStringSmallArrayFt getAtSmallString;\ 1651 getAtVoidSmallArrayFt getAtVoid;\ 1652 getAtSmallContainerSmallArrayFt getAtSmallContainer;\ 1653 getAtNDupSmallArrayFt getAtNDup;\ 1654 getAtNDupUndefinedSmallArrayFt getAtNDupUndefined;\ 1655 getAtNDupBoolSmallArrayFt getAtNDupBool;\ 1656 getAtNDupDoubleSmallArrayFt getAtNDupDouble;\ 1657 getAtNDupIntSmallArrayFt getAtNDupInt;\ 1658 getAtNDupInt32SmallArrayFt getAtNDupInt32;\ 1659 getAtNDupUintSmallArrayFt getAtNDupUint;\ 1660 getAtNDupUint32SmallArrayFt getAtNDupUint32;\ 1661 getAtNDupSSmallArrayFt getAtNDupS;\ 1662 getAtNDupDictSmallArrayFt getAtNDupDict;\ 1663 getAtNDupArraySmallArrayFt getAtNDupArray;\ 1664 getAtNDupSmallBoolSmallArrayFt getAtNDupSmallBool;\ 1665 getAtNDupSmallBytesSmallArrayFt getAtNDupSmallBytes;\ 1666 getAtNDupSmallDoubleSmallArrayFt getAtNDupSmallDouble;\ 1667 getAtNDupSmallIntSmallArrayFt getAtNDupSmallInt;\ 1668 getAtNDupSmallJsonSmallArrayFt getAtNDupSmallJson;\ 1669 getAtNDupSmallStringSmallArrayFt getAtNDupSmallString;\ 1670 getAtNDupVoidSmallArrayFt getAtNDupVoid;\ 1671 getAtNDupSmallContainerSmallArrayFt getAtNDupSmallContainer;\ 1672 setAtSmallArrayFt setAt;\ 1673 setAtUndefinedSmallArrayFt setAtUndefined;\ 1674 setAtBoolSmallArrayFt setAtBool;\ 1675 setAtDoubleSmallArrayFt setAtDouble;\ 1676 setAtIntSmallArrayFt setAtInt;\ 1677 setAtSSmallArrayFt setAtS;\ 1678 setAtCharSmallArrayFt setAtChar;\ 1679 setAtDictSmallArrayFt setAtDict;\ 1680 setAtArraySmallArrayFt setAtArray;\ 1681 setAtArraycSmallArrayFt setAtArrayc;\ 1682 setAtCArraycSmallArrayFt setAtCArrayc;\ 1683 setAtSmallBoolSmallArrayFt setAtSmallBool;\ 1684 setAtSmallBytesSmallArrayFt setAtSmallBytes;\ 1685 setAtSmallDoubleSmallArrayFt setAtSmallDouble;\ 1686 setAtSmallIntSmallArrayFt setAtSmallInt;\ 1687 setAtSmallJsonSmallArrayFt setAtSmallJson;\ 1688 setAtSmallStringSmallArrayFt setAtSmallString;\ 1689 setAtSmallContainerSmallArrayFt setAtSmallContainer;\ 1690 setAtNFreeSmallArrayFt setAtNFree;\ 1691 setAtNFreeUndefinedSmallArrayFt setAtNFreeUndefined;\ 1692 setAtNFreeSSmallArrayFt setAtNFreeS;\ 1693 setAtNFreeDictSmallArrayFt setAtNFreeDict;\ 1694 setAtNFreeArraySmallArrayFt setAtNFreeArray;\ 1695 setAtNFreeArraycSmallArrayFt setAtNFreeArrayc;\ 1696 setAtNFreeSmallBoolSmallArrayFt setAtNFreeSmallBool;\ 1697 setAtNFreeSmallBytesSmallArrayFt setAtNFreeSmallBytes;\ 1698 setAtNFreeSmallDoubleSmallArrayFt setAtNFreeSmallDouble;\ 1699 setAtNFreeSmallIntSmallArrayFt setAtNFreeSmallInt;\ 1700 setAtNFreeSmallJsonSmallArrayFt setAtNFreeSmallJson;\ 1701 setAtNFreeSmallStringSmallArrayFt setAtNFreeSmallString;\ 1702 setAtNFreeSmallContainerSmallArrayFt setAtNFreeSmallContainer;\ 1703 setPAtArraySmallArrayFt setPAtArray;\ 1704 setPAtDictSmallArrayFt setPAtDict;\ 1705 setPAtSmallJsonSmallArrayFt setPAtSmallJson;\ 1706 setPAtSmallStringSmallArrayFt setPAtSmallString;\ 1707 setPAtNFreeArraySmallArrayFt setPAtNFreeArray;\ 1708 setPAtNFreeDictSmallArrayFt setPAtNFreeDict;\ 1709 setPAtNFreeSmallJsonSmallArrayFt setPAtNFreeSmallJson;\ 1710 setPAtNFreeSmallStringSmallArrayFt setPAtNFreeSmallString;\ 1711 getNumSmallArrayFt getNum;\ 1712 hasSmallArrayFt has;\ 1713 hasUndefinedSmallArrayFt hasUndefined;\ 1714 hasBoolSmallArrayFt hasBool;\ 1715 hasDoubleSmallArrayFt hasDouble;\ 1716 hasIntSmallArrayFt hasInt;\ 1717 hasSSmallArrayFt hasS;\ 1718 hasCharSmallArrayFt hasChar;\ 1719 hasDictSmallArrayFt hasDict;\ 1720 hasArraySmallArrayFt hasArray;\ 1721 hasArraycSmallArrayFt hasArrayc;\ 1722 hasCArraycSmallArrayFt hasCArrayc;\ 1723 hasSmallBoolSmallArrayFt hasSmallBool;\ 1724 hasSmallBytesSmallArrayFt hasSmallBytes;\ 1725 hasSmallDoubleSmallArrayFt hasSmallDouble;\ 1726 hasSmallIntSmallArrayFt hasSmallInt;\ 1727 hasSmallJsonSmallArrayFt hasSmallJson;\ 1728 hasSmallStringSmallArrayFt hasSmallString;\ 1729 hasSmallContainerSmallArrayFt hasSmallContainer;\ 1730 indexOfSmallArrayFt indexOf;\ 1731 indexOfUndefinedSmallArrayFt indexOfUndefined;\ 1732 indexOfBoolSmallArrayFt indexOfBool;\ 1733 indexOfDoubleSmallArrayFt indexOfDouble;\ 1734 indexOfIntSmallArrayFt indexOfInt;\ 1735 indexOfSSmallArrayFt indexOfS;\ 1736 indexOfCharSmallArrayFt indexOfChar;\ 1737 indexOfDictSmallArrayFt indexOfDict;\ 1738 indexOfArraySmallArrayFt indexOfArray;\ 1739 indexOfArraycSmallArrayFt indexOfArrayc;\ 1740 indexOfCArraycSmallArrayFt indexOfCArrayc;\ 1741 indexOfSmallBoolSmallArrayFt indexOfSmallBool;\ 1742 indexOfSmallBytesSmallArrayFt indexOfSmallBytes;\ 1743 indexOfSmallDoubleSmallArrayFt indexOfSmallDouble;\ 1744 indexOfSmallIntSmallArrayFt indexOfSmallInt;\ 1745 indexOfSmallJsonSmallArrayFt indexOfSmallJson;\ 1746 indexOfSmallStringSmallArrayFt indexOfSmallString;\ 1747 indexOfSmallContainerSmallArrayFt indexOfSmallContainer;\ 1748 binarySearchSmallArrayFt binarySearch;\ 1749 binarySearchUndefinedSmallArrayFt binarySearchUndefined;\ 1750 binarySearchBoolSmallArrayFt binarySearchBool;\ 1751 binarySearchDoubleSmallArrayFt binarySearchDouble;\ 1752 binarySearchIntSmallArrayFt binarySearchInt;\ 1753 binarySearchSSmallArrayFt binarySearchS;\ 1754 binarySearchCharSmallArrayFt binarySearchChar;\ 1755 binarySearchDictSmallArrayFt binarySearchDict;\ 1756 binarySearchArraySmallArrayFt binarySearchArray;\ 1757 binarySearchArraycSmallArrayFt binarySearchArrayc;\ 1758 binarySearchCArraycSmallArrayFt binarySearchCArrayc;\ 1759 binarySearchSmallBoolSmallArrayFt binarySearchSmallBool;\ 1760 binarySearchSmallBytesSmallArrayFt binarySearchSmallBytes;\ 1761 binarySearchSmallDoubleSmallArrayFt binarySearchSmallDouble;\ 1762 binarySearchSmallIntSmallArrayFt binarySearchSmallInt;\ 1763 binarySearchSmallJsonSmallArrayFt binarySearchSmallJson;\ 1764 binarySearchSmallStringSmallArrayFt binarySearchSmallString;\ 1765 binarySearchSmallContainerSmallArrayFt binarySearchSmallContainer;\ 1766 uniqSmallArrayFt uniq;\ 1767 icHasSmallArrayFt icHas;\ 1768 icHasSSmallArrayFt icHasS;\ 1769 icHasCharSmallArrayFt icHasChar;\ 1770 icHasDictSmallArrayFt icHasDict;\ 1771 icHasArraySmallArrayFt icHasArray;\ 1772 icHasArraycSmallArrayFt icHasArrayc;\ 1773 icHasCArraycSmallArrayFt icHasCArrayc;\ 1774 icHasSmallJsonSmallArrayFt icHasSmallJson;\ 1775 icHasSmallStringSmallArrayFt icHasSmallString;\ 1776 icIndexOfSmallArrayFt icIndexOf;\ 1777 icIndexOfSSmallArrayFt icIndexOfS;\ 1778 icIndexOfCharSmallArrayFt icIndexOfChar;\ 1779 icIndexOfDictSmallArrayFt icIndexOfDict;\ 1780 icIndexOfArraySmallArrayFt icIndexOfArray;\ 1781 icIndexOfArraycSmallArrayFt icIndexOfArrayc;\ 1782 icIndexOfCArraycSmallArrayFt icIndexOfCArrayc;\ 1783 icIndexOfSmallJsonSmallArrayFt icIndexOfSmallJson;\ 1784 icIndexOfSmallStringSmallArrayFt icIndexOfSmallString;\ 1785 icBinarySearchSmallArrayFt icBinarySearch;\ 1786 icBinarySearchSSmallArrayFt icBinarySearchS;\ 1787 icBinarySearchCharSmallArrayFt icBinarySearchChar;\ 1788 icBinarySearchDictSmallArrayFt icBinarySearchDict;\ 1789 icBinarySearchArraySmallArrayFt icBinarySearchArray;\ 1790 icBinarySearchArraycSmallArrayFt icBinarySearchArrayc;\ 1791 icBinarySearchCArraycSmallArrayFt icBinarySearchCArrayc;\ 1792 icBinarySearchSmallJsonSmallArrayFt icBinarySearchSmallJson;\ 1793 icBinarySearchSmallStringSmallArrayFt icBinarySearchSmallString;\ 1794 icUniqSmallArrayFt icUniq;\ 1795 compactSmallArrayFt compact;\ 1796 emptySmallArrayFt empty;\ 1797 isEmptySmallArrayFt isEmpty;\ 1798 isBlankSmallArrayFt isBlank;\ 1799 forEachSmallArrayFt forEach;\ 1800 enumerateSmallArrayFt enumerate;\ 1801 iterStartSmallArrayFt iterStart;\ 1802 iterStartLastSmallArrayFt iterStartLast;\ 1803 iterStartFromSmallArrayFt iterStartFrom;\ 1804 iterStartFromStepSmallArrayFt iterStartFromStep;\ 1805 iterNextSmallArrayFt iterNext;\ 1806 iterElementSmallArrayFt iterElement;\ 1807 iterIndexSmallArrayFt iterIndex;\ 1808 iterStepSmallArrayFt iterStep;\ 1809 joinSmallArrayFt join;\ 1810 joinCharSmallArrayFt joinChar;\ 1811 joinSmallJsonSmallArrayFt joinSmallJson;\ 1812 joinSmallStringSmallArrayFt joinSmallString;\ 1813 joinSSmallArrayFt joinS;\ 1814 joinCharSSmallArrayFt joinCharS;\ 1815 joinSmallJsonSSmallArrayFt joinSmallJsonS;\ 1816 joinSmallStringSSmallArrayFt joinSmallStringS;\ 1817 zipSmallArrayFt zip;\ 1818 zipSmallJsonSmallArrayFt zipSmallJson;\ 1819 zipSmallJsonSmallArraySmallArrayFt zipSmallJsonSmallArray;\ 1820 zipSmallJsonSmallJsonSmallArrayFt zipSmallJsonSmallJson;\ 1821 zipSmallJsonCharSmallArrayFt zipSmallJsonChar;\ 1822 zipSmallJsonCCharSmallArrayFt zipSmallJsonCChar;\ 1823 zipArraySmallArrayFt zipArray;\ 1824 zipCArraySmallArrayFt zipCArray;\ 1825 zipArraySmallJsonSmallArrayFt zipArraySmallJson;\ 1826 zipCArraySmallJsonSmallArrayFt zipCArraySmallJson;\ 1827 zipCharSmallArrayFt zipChar;\ 1828 zipCCharSmallArrayFt zipCChar;\ 1829 zipArrayCharSmallArrayFt zipArrayChar;\ 1830 zipCArrayCharSmallArrayFt zipCArrayChar;\ 1831 zipArrayCCharSmallArrayFt zipArrayCChar;\ 1832 zipCArrayCCharSmallArrayFt zipCArrayCChar;\ 1833 logSmallArrayFt log;\ 1834 readTextSmallArrayFt readText;\ 1835 readTextSmallJsonSmallArrayFt readTextSmallJson;\ 1836 readTextSmallStringSmallArrayFt readTextSmallString;\ 1837 readStreamSmallArrayFt readStream;\ 1838 writeTextSmallArrayFt writeText;\ 1839 writeTextSmallJsonSmallArrayFt writeTextSmallJson;\ 1840 writeTextSmallStringSmallArrayFt writeTextSmallString;\ 1841 writeStreamSmallArrayFt writeStream;\ 1842 appendTextSmallArrayFt appendText;\ 1843 appendTextSmallStringSmallArrayFt appendTextSmallString;\ 1844 typeStringSmallArrayFt typeString;\ 1845 typeSmallStringSmallArrayFt typeSmallString;\ 1846 typeSmallArrayFt type;\ 1847 typeStringsSmallArrayFt typeStrings;\ 1848 typeSmallStringsSmallArrayFt typeSmallStrings;\ 1849 typesSmallArrayFt types;\ 1850 isETypeSmallArrayFt isEType;\ 1851 isEUndefinedSmallArrayFt isEUndefined;\ 1852 isEBoolSmallArrayFt isEBool;\ 1853 isEContainerSmallArrayFt isEContainer;\ 1854 isEDictSmallArrayFt isEDict;\ 1855 isEDoubleSmallArrayFt isEDouble;\ 1856 isEIntSmallArrayFt isEInt;\ 1857 isEStringSmallArrayFt isEString;\ 1858 isEFaststringSmallArrayFt isEFaststring;\ 1859 isEArraySmallArrayFt isEArray;\ 1860 isEBytesSmallArrayFt isEBytes;\ 1861 areAllETypeSmallArrayFt areAllEType;\ 1862 areAllEUndefinedSmallArrayFt areAllEUndefined;\ 1863 areAllEBoolSmallArrayFt areAllEBool;\ 1864 areAllEContainerSmallArrayFt areAllEContainer;\ 1865 areAllEDictSmallArrayFt areAllEDict;\ 1866 areAllEDoubleSmallArrayFt areAllEDouble;\ 1867 areAllEIntSmallArrayFt areAllEInt;\ 1868 areAllEStringSmallArrayFt areAllEString;\ 1869 areAllEFaststringSmallArrayFt areAllEFaststring;\ 1870 areAllEArraySmallArrayFt areAllEArray;\ 1871 areAllEBytesSmallArrayFt areAllEBytes 1872 1873 1874 1875 1876 1877 1878 typedef struct { 1879 freeSmallArrayFt free; 1880 terminateSmallArrayFt terminate; 1881 toStringSmallArrayFt toString; 1882 duplicateSmallArrayFt duplicate; 1883 smashSmallArrayFt smash; 1884 finishSmallArrayFt finish; 1885 1886 SMALLARRAYFUNCTIONST; 1887 } smallArrayFunctionst; 1888 1889 /** 1890 * class 1891 */ 1892 struct smallArray { 1893 const char *type; 1894 smallArrayFunctionst *f; 1895 1896 // internal 1897 sArrayt *a; 1898 ssize_t iterIndex; 1899 int64_t iterStep; 1900 baset* iterElement; 1901 // iterElementDataType indicates what the type baset object in iterElement 1902 // if iterElement is not small* class object then finish must not be called 1903 // in the iterator 1904 // baset objects not from small* classes are stored directly in smallContainers 1905 // values: SH_DT_UNKNOWN, SH_DT_BASET 1906 char iterElementDataType; 1907 }; 1908 1909 // smallArray 1910 1911 #define createSmallArray(obj) ;smallArrayt obj; initiateSmallArray(&obj) 1912 #define createAllocateSmallArray(obj) ;smallArrayt *obj; initiateAllocateSmallArray(&obj) 1913 1914 void initiateSmallArray(smallArrayt *self); 1915 void initiateAllocateSmallArray(smallArrayt **self); 1916 void finalizeRecycleSmallArray(void *arg UNUSED); 1917 void finalizeSmallArray(void); 1918 1919 // initialize class methods, call registerMethodsSmallArray from classes inheriting this class 1920 void registerMethodsSmallArray(smallArrayFunctionst *f); 1921 1922 smallArrayt* allocSmallArray(void); 1923 smallArrayt* allocArraySmallArray(char **array); 1924 smallArrayt* allocCArraySmallArray(const char **array); 1925 1926 // terminate smallArrayt val when it is out of scope 1927 void cleanUpSmallArrayTerminateG(smallArrayt **val); 1928 1929 // free smallArrayt local val when it is out of scope 1930 void cleanUpSmallArrayFreeLocalG(smallArrayt *val); 1931 1932 // free smallArrayt val when it is out of scope 1933 void cleanUpSmallArrayFreeG(smallArrayt **val); 1934 1935 // finish smallArrayt val when it is out of scope 1936 void cleanUpSmallArrayFinishG(smallArrayt **val); 1937 1938 // dispose smallArrayt val when it is out of scope 1939 void cleanUpSmallArrayDisposeG(smallArrayt *val); 1940 1941 // smash smallArrayt val when it is out of scope 1942 void cleanUpSmallArraySmashG(smallArrayt **val); 1943 1944 /** 1945 * declare pointer name with type smallArrayt and terminate name when it is out of scope 1946 */ 1947 #define cleanSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayTerminateG) 1948 1949 /** 1950 * allocate smallArray (pointer) and clean up when it is out of scope 1951 */ 1952 #define cleanAllocateSmallArray(obj) ;cleanSmallArrayP(obj); initiateAllocateSmallArray(&obj) 1953 1954 /** 1955 * declare local object name with type smallArrayt and free name when it is out of scope 1956 */ 1957 #define cleanSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayFreeLocalG); initiateSmallArray(&name) 1958 1959 /** 1960 * declare pointer name with type smallArrayt and free name when it is out of scope 1961 */ 1962 #define cleanFreeSmallArray(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFreeG) 1963 1964 /** 1965 * declare pointer name with Type smallArrayt and finish name when it is out of scope 1966 */ 1967 #define cleanFinishSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArrayFinishG) 1968 1969 /** 1970 * declare local object name with Type smallArrayt and dispose name when it is out of scope 1971 */ 1972 #define cleanDisposeSmallArray(name) smallArrayt name CLEANUP(cleanUpSmallArrayDisposeG); initiateSmallArray(&name) 1973 1974 /** 1975 * declare pointer name with Type smallArrayt and smash name when it is out of scope 1976 */ 1977 #define cleanSmashSmallArrayP(name) smallArrayt *name CLEANUP(cleanUpSmallArraySmashG) 1978 1979 /** 1980 * create String Array Function 1981 * 1982 * create a smallArray for list of strings 1983 * 1984 * \return 1985 * smallArray 1986 */ 1987 smallArrayt* createSAF(const char *paramType, ...); 1988 #define createSA(...) createSAF("", __VA_ARGS__, NULL) 1989 1990 smallArrayt* allocSmallArrayG(smallArrayt *self UNUSED); 1991 1992 smallArrayt* duplicateSmallArrayG (smallArrayt *self); 1993 1994 void freeSmallArrayG (smallArrayt *self); 1995 1996 smallArrayt* fromArraySmallArrayG(smallArrayt *self, char **array, size_t size); 1997 smallArrayt* fromCArraySmallArrayG(smallArrayt *self, const char **array, size_t size); 1998 smallArrayt* setFromSmallArrayG(smallArrayt *self, char **array); 1999 smallArrayt* setFromCSmallArrayG(smallArrayt *self, const char **array); 2000 2001 smallArrayt* pushSmallArrayG (smallArrayt *self, baset *value); 2002 smallArrayt* pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED); 2003 smallArrayt* pushBoolSmallArrayG (smallArrayt *self, bool value); 2004 smallArrayt* pushDoubleSmallArrayG (smallArrayt *self, double value); 2005 smallArrayt* pushIntSmallArrayG (smallArrayt *self, int64_t value); 2006 smallArrayt* pushSSmallArrayG (smallArrayt *self, const char *string); 2007 smallArrayt* pushCharSmallArrayG (smallArrayt *self, char c); 2008 smallArrayt* pushDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2009 smallArrayt* pushArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2010 smallArrayt* pushArraycSmallArrayG (smallArrayt *self, char **array); 2011 smallArrayt* pushCArraycSmallArrayG (smallArrayt *self, const char **array); 2012 smallArrayt* pushVoidSmallArrayG (smallArrayt *self, void *value); 2013 smallArrayt* pushSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2014 smallArrayt* pushSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2015 smallArrayt* pushSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2016 smallArrayt* pushSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2017 smallArrayt* pushSmallJsonSmallArrayG (smallArrayt *self, smallJsont *value); 2018 smallArrayt* pushSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2019 smallArrayt* pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 2020 2021 smallArrayt* pushNFreeSmallArrayG (smallArrayt *self, baset *value); 2022 smallArrayt* pushNFreeUndefinedSmallArrayG (smallArrayt *self, undefinedt *value); 2023 smallArrayt* pushNFreeSSmallArrayG (smallArrayt *self, char *string); 2024 smallArrayt* pushNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2025 smallArrayt* pushNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2026 smallArrayt* pushNFreeArraycSmallArrayG (smallArrayt *self, char **array); 2027 smallArrayt* pushNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2028 smallArrayt* pushNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2029 smallArrayt* pushNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2030 smallArrayt* pushNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2031 smallArrayt* pushNFreeSmallJsonSmallArrayG (smallArrayt *self, smallJsont *value); 2032 smallArrayt* pushNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2033 smallArrayt* pushNFreeSmallContainerSmallArrayG (smallArrayt *self, smallContainert *container); 2034 2035 baset* popSmallArrayG (smallArrayt *self, baset* retType UNUSED); 2036 undefinedt* popUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED); 2037 bool popBoolSmallArrayG (smallArrayt *self, bool retType UNUSED); 2038 double popDoubleSmallArrayG (smallArrayt *self, double retType UNUSED); 2039 int64_t popIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED); 2040 int32_t popInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED); 2041 uint64_t popUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED); 2042 uint32_t popUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED); 2043 char* popSSmallArrayG (smallArrayt *self, char* retType UNUSED); 2044 smallDictt* popDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED); 2045 smallArrayt* popArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED); 2046 smallBoolt* popSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED); 2047 smallBytest* popSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED); 2048 smallDoublet* popSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED); 2049 smallIntt* popSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED); 2050 smallJsont* popSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED); 2051 smallStringt* popSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED); 2052 void* popVoidSmallArrayG (smallArrayt *self, void* retType UNUSED); 2053 smallContainert* popSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED); 2054 2055 smallArrayt* prependSmallArrayG (smallArrayt *self, baset *value); 2056 smallArrayt* prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED); 2057 smallArrayt* prependBoolSmallArrayG (smallArrayt *self, bool value); 2058 smallArrayt* prependDoubleSmallArrayG (smallArrayt *self, double value); 2059 smallArrayt* prependIntSmallArrayG (smallArrayt *self, int64_t value); 2060 smallArrayt* prependSSmallArrayG (smallArrayt *self, const char *string); 2061 smallArrayt* prependCharSmallArrayG (smallArrayt *self, char c); 2062 smallArrayt* prependDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2063 smallArrayt* prependArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2064 smallArrayt* prependArraycSmallArrayG (smallArrayt *self, char **array); 2065 smallArrayt* prependCArraycSmallArrayG (smallArrayt *self, const char **array); 2066 smallArrayt* prependVoidSmallArrayG (smallArrayt *self, void *value); 2067 smallArrayt* prependSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2068 smallArrayt* prependSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2069 smallArrayt* prependSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2070 smallArrayt* prependSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2071 smallArrayt* prependSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json); 2072 smallArrayt* prependSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2073 smallArrayt* prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 2074 2075 smallArrayt* prependNFreeSmallArrayG (smallArrayt *self, baset *value); 2076 smallArrayt* prependNFreeUndefinedSmallArrayG (smallArrayt *self, undefinedt *value); 2077 smallArrayt* prependNFreeSSmallArrayG (smallArrayt *self, char *string); 2078 smallArrayt* prependNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2079 smallArrayt* prependNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2080 smallArrayt* prependNFreeArraycSmallArrayG (smallArrayt *self, char **array); 2081 smallArrayt* prependNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2082 smallArrayt* prependNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2083 smallArrayt* prependNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2084 smallArrayt* prependNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2085 smallArrayt* prependNFreeSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json); 2086 smallArrayt* prependNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2087 smallArrayt* prependNFreeSmallContainerSmallArrayG (smallArrayt *self, smallContainert *container); 2088 2089 baset* dequeueSmallArrayG (smallArrayt *self, baset* retType UNUSED); 2090 undefinedt* dequeueUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED); 2091 bool dequeueBoolSmallArrayG (smallArrayt *self, bool retType UNUSED); 2092 double dequeueDoubleSmallArrayG (smallArrayt *self, double retType UNUSED); 2093 int64_t dequeueIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED); 2094 int32_t dequeueInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED); 2095 uint64_t dequeueUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED); 2096 uint32_t dequeueUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED); 2097 char* dequeueSSmallArrayG (smallArrayt *self, char* retType UNUSED); 2098 smallDictt* dequeueDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED); 2099 smallArrayt* dequeueArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED); 2100 smallBoolt* dequeueSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED); 2101 smallBytest* dequeueSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED); 2102 smallDoublet* dequeueSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED); 2103 smallIntt* dequeueSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED); 2104 smallJsont* dequeueSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED); 2105 smallStringt* dequeueSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED); 2106 void* dequeueVoidSmallArrayG (smallArrayt *self, void* retType UNUSED); 2107 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED); 2108 2109 2110 baset* getAtSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index); 2111 undefinedt* getAtUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index); 2112 bool getAtBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index); 2113 bool* getAtBoolPSmallArrayG (smallArrayt *self, bool* retType UNUSED, int64_t index); 2114 double getAtDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index); 2115 double* getAtDoublePSmallArrayG (smallArrayt *self, double* retType UNUSED, int64_t index); 2116 int64_t getAtIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index); 2117 int64_t* getAtIntPSmallArrayG (smallArrayt *self, int64_t* retType UNUSED, int64_t index); 2118 int32_t getAtInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index); 2119 int32_t* getAtInt32PSmallArrayG (smallArrayt *self, int32_t* retType UNUSED, int64_t index); 2120 uint64_t getAtUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index); 2121 uint64_t* getAtUintPSmallArrayG (smallArrayt *self, uint64_t* retType UNUSED, int64_t index); 2122 uint32_t getAtUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index); 2123 uint32_t* getAtUint32PSmallArrayG (smallArrayt *self, uint32_t* retType UNUSED, int64_t index); 2124 char* getAtSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index); 2125 smallDictt* getAtDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index); 2126 smallArrayt* getAtArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index); 2127 smallBoolt* getAtSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index); 2128 smallBytest* getAtSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index); 2129 smallDoublet* getAtSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index); 2130 smallIntt* getAtSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index); 2131 smallJsont* getAtSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index); 2132 smallStringt* getAtSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index); 2133 void* getAtVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index); 2134 smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index); 2135 2136 baset* getAtNDupSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index); 2137 undefinedt* getAtNDupUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index); 2138 bool getAtNDupBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index); 2139 double getAtNDupDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index); 2140 int64_t getAtNDupIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index); 2141 int32_t getAtNDupInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index); 2142 uint64_t getAtNDupUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index); 2143 uint32_t getAtNDupUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index); 2144 char* getAtNDupSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index); 2145 smallDictt* getAtNDupDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index); 2146 smallArrayt* getAtNDupArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index); 2147 smallBoolt* getAtNDupSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index); 2148 smallBytest* getAtNDupSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index); 2149 smallDoublet* getAtNDupSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index); 2150 smallIntt* getAtNDupSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index); 2151 smallJsont* getAtNDupSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index); 2152 smallStringt* getAtNDupSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index); 2153 void* getAtNDupVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index); 2154 smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index); 2155 2156 smallArrayt* setAtSmallArrayG (smallArrayt *self, int64_t index, baset *value); 2157 smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value); 2158 smallArrayt* setAtBoolSmallArrayG (smallArrayt *self, int64_t index, bool value); 2159 smallArrayt* setAtDoubleSmallArrayG (smallArrayt *self, int64_t index, double value); 2160 smallArrayt* setAtIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value); 2161 smallArrayt* setAtSSmallArrayG (smallArrayt *self, int64_t index, const char *string); 2162 smallArrayt* setAtCharSmallArrayG (smallArrayt *self, int64_t index, char c); 2163 smallArrayt* setAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2164 smallArrayt* setAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2165 smallArrayt* setAtArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 2166 smallArrayt* setAtCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array); 2167 smallArrayt* setAtVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 2168 smallArrayt* setAtSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 2169 smallArrayt* setAtSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 2170 smallArrayt* setAtSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 2171 smallArrayt* setAtSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 2172 smallArrayt* setAtSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *value); 2173 smallArrayt* setAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2174 smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 2175 smallArrayt* setAtNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value); 2176 smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value); 2177 smallArrayt* setAtNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string); 2178 smallArrayt* setAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2179 smallArrayt* setAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2180 smallArrayt* setAtNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 2181 smallArrayt* setAtNFreeVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 2182 smallArrayt* setAtNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 2183 smallArrayt* setAtNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 2184 smallArrayt* setAtNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 2185 smallArrayt* setAtNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 2186 smallArrayt* setAtNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *value); 2187 smallArrayt* setAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2188 smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 2189 2190 smallArrayt* setPAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2191 smallArrayt* setPAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2192 smallArrayt* setPAtSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *json); 2193 smallArrayt* setPAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2194 smallArrayt* setPAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2195 smallArrayt* setPAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2196 smallArrayt* setPAtNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *json); 2197 smallArrayt* setPAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2198 2199 double getNumSmallArrayG (smallArrayt *self, int64_t index); 2200 2201 smallArrayt* reverseSmallArrayG (smallArrayt *self); 2202 smallArrayt* appendSmallArrayG (smallArrayt *self, smallArrayt *array); 2203 smallArrayt* appendSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json); 2204 smallArrayt* appendNSmashSmallArrayG (smallArrayt *self, smallArrayt *array); 2205 smallArrayt* appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json); 2206 smallArrayt* appendArraySmallArrayG (smallArrayt *self, char **array); 2207 smallArrayt* appendNSmashArraySmallArrayG (smallArrayt *self, char **array); 2208 smallArrayt* appendCArraySmallArrayG (smallArrayt *self, const char **array); 2209 smallArrayt* shiftSmallArrayG (smallArrayt *self, smallArrayt *array); 2210 smallArrayt* shiftSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json); 2211 smallArrayt* shiftNSmashSmallArrayG (smallArrayt *self, smallArrayt *array); 2212 smallArrayt* shiftNSmashSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json); 2213 2214 smallArrayt* addSmallArrayG (smallArrayt *self, smallArrayt *array); 2215 smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end); 2216 smallArrayt* cropSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 2217 baset* cropElemSmallArrayG (smallArrayt *self, int64_t index); 2218 undefinedt* cropElemUndefinedSmallArrayG (smallArrayt *self, int64_t index); 2219 bool cropElemBoolSmallArrayG (smallArrayt *self, int64_t index); 2220 double cropElemDoubleSmallArrayG (smallArrayt *self, int64_t index); 2221 int64_t cropElemIntSmallArrayG (smallArrayt *self, int64_t index); 2222 int32_t cropElemInt32SmallArrayG (smallArrayt *self, int64_t index); 2223 uint64_t cropElemUintSmallArrayG (smallArrayt *self, int64_t index); 2224 uint32_t cropElemUint32SmallArrayG (smallArrayt *self, int64_t index); 2225 char* cropElemSSmallArrayG (smallArrayt *self, int64_t index); 2226 smallDictt* cropElemDictSmallArrayG (smallArrayt *self, int64_t index); 2227 smallArrayt* cropElemArraySmallArrayG (smallArrayt *self, int64_t index); 2228 smallBoolt* cropElemSmallBoolSmallArrayG (smallArrayt *self, int64_t index); 2229 smallBytest* cropElemSmallBytesSmallArrayG (smallArrayt *self, int64_t index); 2230 smallDoublet* cropElemSmallDoubleSmallArrayG (smallArrayt *self, int64_t index); 2231 smallIntt* cropElemSmallIntSmallArrayG (smallArrayt *self, int64_t index); 2232 smallJsont* cropElemSmallJsonSmallArrayG (smallArrayt *self, int64_t index); 2233 smallStringt* cropElemSmallStringSmallArrayG (smallArrayt *self, int64_t index); 2234 void* cropElemVoidSmallArrayG (smallArrayt *self, int64_t index); 2235 smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index); 2236 smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end); 2237 smallArrayt* insertSmallArrayG (smallArrayt *self, int64_t index, smallArrayt *toInsert); 2238 smallArrayt* insertSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *toInsert); 2239 smallArrayt* insertNSmashSmallArrayG (smallArrayt *self, int64_t index, smallArrayt *toInsert); 2240 smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert); 2241 2242 smallArrayt* injectSmallArrayG (smallArrayt *self, int64_t index, baset *value); 2243 smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value); 2244 smallArrayt* injectBoolSmallArrayG (smallArrayt *self, int64_t index, bool value); 2245 smallArrayt* injectDoubleSmallArrayG (smallArrayt *self, int64_t index, double value); 2246 smallArrayt* injectIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value); 2247 smallArrayt* injectSSmallArrayG (smallArrayt *self, int64_t index, const char *string); 2248 smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c); 2249 smallArrayt* injectDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2250 smallArrayt* injectArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2251 smallArrayt* injectArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 2252 smallArrayt* injectCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array); 2253 smallArrayt* injectVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 2254 smallArrayt* injectSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 2255 smallArrayt* injectSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 2256 smallArrayt* injectSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 2257 smallArrayt* injectSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 2258 smallArrayt* injectSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string); 2259 smallArrayt* injectSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2260 smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 2261 smallArrayt* injectNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value); 2262 smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value); 2263 smallArrayt* injectNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string); 2264 smallArrayt* injectNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict); 2265 smallArrayt* injectNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array); 2266 smallArrayt* injectNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array); 2267 smallArrayt* injectNFreeVoidSmallArrayG (smallArrayt *self, int64_t index, void *value); 2268 smallArrayt* injectNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value); 2269 smallArrayt* injectNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value); 2270 smallArrayt* injectNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value); 2271 smallArrayt* injectNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value); 2272 smallArrayt* injectNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string); 2273 smallArrayt* injectNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string); 2274 smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container); 2275 2276 smallArrayt* delSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 2277 smallArrayt* delElemSmallArrayG (smallArrayt *self, int64_t index); 2278 smallArrayt* removeSmallArrayG (smallArrayt *self, int64_t start, int64_t end); 2279 smallArrayt* removeElemSmallArrayG (smallArrayt *self, int64_t index); 2280 smallArrayt* sortSmallArrayG (smallArrayt *self); 2281 smallArrayt* sortFSmallArrayG (smallArrayt *self, shCmpt compareFunction); 2282 smallArrayt* icSortSmallArrayG (smallArrayt *self); 2283 bool equalSmallArrayG (smallArrayt *self, smallArrayt *array); 2284 bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array); 2285 bool equalSmallArrayArrayG (smallArrayt* self, char ** p2); 2286 bool equalSmallArrayCArrayG (smallArrayt* self, const char ** p2); 2287 bool equalSmallArrayBaseG (smallArrayt* self, baset* p2); 2288 bool icEqualSmallArrayG (smallArrayt *self, smallArrayt *array); 2289 bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array); 2290 bool icEqualSmallArrayArrayG (smallArrayt* self, char ** p2); 2291 bool icEqualSmallArrayCArrayG (smallArrayt* self, const char ** p2); 2292 bool icEqualSmallArrayBaseG (smallArrayt* self, baset* p2); 2293 size_t lenSmallArrayG (smallArrayt *self); 2294 smallArrayt* trimSmallArrayG (smallArrayt *self); 2295 bool hasSmallArrayG (smallArrayt *self, baset *value); 2296 bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 2297 bool hasBoolSmallArrayG (smallArrayt *self, bool value); 2298 bool hasDoubleSmallArrayG (smallArrayt *self, double value); 2299 bool hasIntSmallArrayG (smallArrayt *self, int64_t value); 2300 bool hasSSmallArrayG (smallArrayt *self, const char *string); 2301 bool hasCharSmallArrayG (smallArrayt *self, char c); 2302 bool hasDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2303 bool hasArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2304 bool hasArraycSmallArrayG (smallArrayt *self, char **array); 2305 bool hasCArraycSmallArrayG (smallArrayt *self, const char **array); 2306 bool hasSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2307 bool hasSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2308 bool hasSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2309 bool hasSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2310 bool hasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2311 bool hasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2312 bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 2313 ssize_t indexOfSmallArrayG (smallArrayt *self, baset *value); 2314 ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 2315 ssize_t indexOfBoolSmallArrayG (smallArrayt *self, bool value); 2316 ssize_t indexOfDoubleSmallArrayG (smallArrayt *self, double value); 2317 ssize_t indexOfIntSmallArrayG (smallArrayt *self, int64_t value); 2318 ssize_t indexOfSSmallArrayG (smallArrayt *self, const char *string); 2319 ssize_t indexOfCharSmallArrayG (smallArrayt *self, char c); 2320 ssize_t indexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2321 ssize_t indexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2322 ssize_t indexOfArraycSmallArrayG (smallArrayt *self, char **array); 2323 ssize_t indexOfCArraycSmallArrayG (smallArrayt *self, const char **array); 2324 ssize_t indexOfSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2325 ssize_t indexOfSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2326 ssize_t indexOfSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2327 ssize_t indexOfSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2328 ssize_t indexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2329 ssize_t indexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2330 ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 2331 ssize_t binarySearchSmallArrayG (smallArrayt *self, baset *value); 2332 ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value); 2333 ssize_t binarySearchBoolSmallArrayG (smallArrayt *self, bool value); 2334 ssize_t binarySearchDoubleSmallArrayG (smallArrayt *self, double value); 2335 ssize_t binarySearchIntSmallArrayG (smallArrayt *self, int64_t value); 2336 ssize_t binarySearchSSmallArrayG (smallArrayt *self, const char *string); 2337 ssize_t binarySearchCharSmallArrayG (smallArrayt *self, char c); 2338 ssize_t binarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2339 ssize_t binarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2340 ssize_t binarySearchArraycSmallArrayG (smallArrayt *self, char **array); 2341 ssize_t binarySearchCArraycSmallArrayG (smallArrayt *self, const char **array); 2342 ssize_t binarySearchSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value); 2343 ssize_t binarySearchSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value); 2344 ssize_t binarySearchSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value); 2345 ssize_t binarySearchSmallIntSmallArrayG (smallArrayt *self, smallIntt *value); 2346 ssize_t binarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2347 ssize_t binarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2348 ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container); 2349 smallArrayt* uniqSmallArrayG(smallArrayt *self, int dum UNUSED); 2350 bool icHasSmallArrayG (smallArrayt *self, baset *value); 2351 bool icHasSSmallArrayG (smallArrayt *self, const char *string); 2352 bool icHasCharSmallArrayG (smallArrayt *self, char c); 2353 bool icHasDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2354 bool icHasArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2355 bool icHasArraycSmallArrayG (smallArrayt *self, char **array); 2356 bool icHasCArraycSmallArrayG (smallArrayt *self, const char **array); 2357 bool icHasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2358 bool icHasSmallStringSmallArrayG(smallArrayt *self, smallStringt *string); 2359 ssize_t icIndexOfSmallArrayG (smallArrayt *self, baset *value); 2360 ssize_t icIndexOfSSmallArrayG (smallArrayt *self, const char *string); 2361 ssize_t icIndexOfCharSmallArrayG (smallArrayt *self, char c); 2362 ssize_t icIndexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2363 ssize_t icIndexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2364 ssize_t icIndexOfArraycSmallArrayG (smallArrayt *self, char **array); 2365 ssize_t icIndexOfCArraycSmallArrayG (smallArrayt *self, const char **array); 2366 ssize_t icIndexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2367 ssize_t icIndexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string); 2368 ssize_t icBinarySearchSmallArrayG (smallArrayt *self, baset *value); 2369 ssize_t icBinarySearchSSmallArrayG (smallArrayt *self, const char *string); 2370 ssize_t icBinarySearchCharSmallArrayG (smallArrayt *self, char c); 2371 ssize_t icBinarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict); 2372 ssize_t icBinarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array); 2373 ssize_t icBinarySearchArraycSmallArrayG (smallArrayt *self, char **array); 2374 ssize_t icBinarySearchCArraycSmallArrayG (smallArrayt *self, const char **array); 2375 ssize_t icBinarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string); 2376 ssize_t icBinarySearchSmallStringSmallArrayG(smallArrayt *self, smallStringt *string); 2377 smallArrayt* icUniqSmallArrayG(smallArrayt *self, int dum UNUSED); 2378 smallArrayt* compactSmallArrayG (smallArrayt *self); 2379 smallArrayt* emptySmallArrayG (smallArrayt *self); 2380 bool isEmptySmallArrayG (smallArrayt *self); 2381 bool isBlankSmallArrayG (smallArrayt *self); 2382 smallStringt* joinSmallArrayG (smallArrayt *self, const char* delim); 2383 smallStringt* joinCharSmallArrayG (smallArrayt *self, char c); 2384 smallStringt* joinSmallJsonSmallArrayG (smallArrayt *self, smallJsont* delim); 2385 smallStringt* joinSmallStringSmallArrayG(smallArrayt *self, smallStringt* delim); 2386 char* joinSSmallArrayG (smallArrayt *self, const char* delim); 2387 char* joinCharSSmallArrayG (smallArrayt *self, char c); 2388 char* joinSmallJsonSSmallArrayG (smallArrayt *self, smallJsont* delim); 2389 char* joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt* delim); 2390 smallArrayt* zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2); 2391 smallArrayt* zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2); 2392 smallArrayt* zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2); 2393 smallArrayt* zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2); 2394 smallArrayt* zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2); 2395 smallArrayt* zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2); 2396 smallArrayt* zipArraySmallArrayG(smallArrayt *self, char** array1, smallArrayt *array2); 2397 smallArrayt* zipCArraySmallArrayG(smallArrayt *self, const char** array1, smallArrayt *array2); 2398 smallArrayt* zipArraySmallJsonSmallArrayG(smallArrayt *self, char** array1, smallJsont *array2); 2399 smallArrayt* zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char** array1, smallJsont *array2); 2400 smallArrayt* zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char** array2); 2401 smallArrayt* zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char** array2); 2402 smallArrayt* zipArrayCharSmallArrayG(smallArrayt *self, char** array1, char** array2); 2403 smallArrayt* zipArrayCCharSmallArrayG(smallArrayt *self, char** array1, const char** array2); 2404 smallArrayt* zipCArrayCharSmallArrayG(smallArrayt *self, const char** array1, char** array2); 2405 smallArrayt* zipCArrayCCharSmallArrayG(smallArrayt *self, const char** array1, const char** array2); 2406 void logSmallArrayG(smallArrayt *self); 2407 smallArrayt* readTextSmallArrayG (smallArrayt *self, const char *filePath); 2408 smallArrayt* readTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath); 2409 smallArrayt* readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath); 2410 smallArrayt* readStreamSmallArrayG (smallArrayt *self, FILE *fp); 2411 bool writeTextSmallArrayG (smallArrayt *self, const char *filePath); 2412 bool writeTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath); 2413 bool writeTextSmallStringSmallArrayG (smallArrayt *self, smallStringt *filePath); 2414 bool writeStreamSmallArrayG (smallArrayt *self, FILE *fp); 2415 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath); 2416 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath); 2417 smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index); 2418 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self); 2419 2420 /** 2421 * forEach - loop macro on list non NULL elements 2422 * skip deleted elements 2423 */ 2424 #define forEachSmallArray(array, element) \ 2425 size_t UNIQVAR(libsheepyInternalIndex) = 0; \ 2426 for (baset *element = array->f->getAt(array, 0); UNIQVAR(libsheepyInternalIndex) < array->f->len(array) ; UNIQVAR(libsheepyInternalIndex)++, element = array->f->getAt(array, (int64_t)UNIQVAR(libsheepyInternalIndex))) \ 2427 if (element) 2428 2429 /** 2430 * forEachType c11 - loop macro on list non NULL elements 2431 * skip deleted elements 2432 * 2433 * return specified type 2434 */ 2435 #define forEachTypeSmallArray(type, array, element) \ 2436 size_t UNIQVAR(libsheepyInternalIndex) = 0; \ 2437 for (type element = getG(array, type, 0); UNIQVAR(libsheepyInternalIndex) < array->f->len(array) ; UNIQVAR(libsheepyInternalIndex)++, element = getG(array, type, UNIQVAR(libsheepyInternalIndex))) \ 2438 if (element) 2439 2440 /** 2441 * enumerate non NULL elements in list 2442 * skip deleted elements 2443 */ 2444 #define enumerateSmallArray(array, element, index) \ 2445 size_t index = 0; \ 2446 for (baset *element = array->f->getAt(array, 0); index < array->f->len(array) ; index++, element = array->f->getAt(array, (int64_t)index)) \ 2447 if (element) 2448 2449 /** 2450 * enumerate non NULL elements in list 2451 * skip deleted elements 2452 * 2453 * return specified type 2454 */ 2455 #define enumerateTypeSmallArray(type, array, element, index) \ 2456 size_t index = 0; \ 2457 for (type element = getG(array, type, 0); index < array->f->len(array) ; index++, element = getG(array, type, (int64_t)index)) \ 2458 if (element) 2459 2460 // end class smallArray 2461