libsheepyCSmallJson.h (233161B)
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 /** \file 28 * smallJson class 29 * 30 * smallJson objects can be either dictionary or array. 31 * This is selected when the first element is inserted. 32 * 33 * With 'set', the smallJson becomes a dictionary.\n 34 * With 'push', the smallJson becomes an array. 35 */ 36 37 #include "../libsheepyObject.h" 38 #include "../libsheepySmall.h" 39 40 // Class smallJson 41 typedef struct smallJson smallJsont; 42 43 /** 44 * help text for this class 45 * It is public declaration so that child classes can add their help text easily: 46 * ret "Child help text \n\n" helpTextSmallJson; 47 */ 48 #define helpTextSmallJson "TODO smallJson help brief, class description /*, definitions,*/ methods, examples" 49 50 // for object inheriting smallJson, cast to smallJson to be able to use this class functions and generics 51 #define cJs(self) ( (smallJsont*) self ) 52 53 // default max value size used in lax_json_create 54 // default is 1MB 55 extern size_t jsonMaxValueBufferSize; 56 57 /** json Path Result 58 * enum type for key type 59 * NOT_A_PATH is a dictionary key 60 */ 61 typedef enum {KEY_IS_NULL=0, NOT_A_PATH, ARRAY_PATH, DICT_PATH} jsonPathRest; 62 63 /** array to convert jsonPathRest to string */ 64 extern const char *jsonPathResS[]; 65 66 typedef void (*freeSmallJsonFt) (smallJsont *self); 67 typedef void (*terminateSmallJsonFt) (smallJsont **self); 68 typedef char* (*toStringSmallJsonFt) (smallJsont *self); 69 typedef smallJsont* (*duplicateSmallJsonFt) (smallJsont *self); 70 71 typedef char* (*escapeSmallJsonFt) (smallJsont *self); 72 73 /** 74 * free index but not the elements 75 * self becomes empty. 76 * 77 * Useful when the objects are shared 78 */ 79 typedef void (*disposeSmallJsonFt) (smallJsont *self); 80 81 /** 82 * free self but not the elements 83 * self becomes empty. 84 * 85 * Useful when the objects are shared 86 */ 87 typedef void (*smashSmallJsonFt) (smallJsont **self); 88 89 /** 90 * free container 91 */ 92 typedef void (*finishSmallJsonFt) (smallJsont **self); 93 94 typedef const char* (*helpSmallJsonFt) (smallJsont *self); 95 96 /** 97 * remove reference to internal sObject, set NULL and 98 * free the iterator 99 * 100 * this function is useful for object not allocated on the heap 101 * to free the iterator element when the object is not used anymore 102 * 103 * for example: 104 * createSmallJson(j); 105 * iter(j, e) { 106 * ... 107 * break; 108 * } 109 * resetG(j); // free iteraror element 110 * 111 */ 112 typedef void (*resetSmallJsonFt) (smallJsont *self); 113 114 /** 115 * get the sobject, data in the container only when the type is dict or array 116 */ 117 typedef smallt* (*getsoSmallJsonFt) (smallJsont *self); 118 119 /** 120 * set the sobject, data in the container only when the type is dict or array 121 * the iterator is reset 122 */ 123 typedef void (*setsoSmallJsonFt) (smallJsont *self, smallt *so); 124 125 /** 126 * allocate a new container for the sobject, the iterator state is copied. Only for type array or dict 127 * after this function is executed, there are 2 containers for one sobject, 128 * only one container should be freed or terminated, the other one should be finished 129 */ 130 typedef smallJsont* (*mirrorSmallJsonFt) (smallJsont *self); 131 132 /** 133 * get top object type string 134 * 135 * \return 136 * type string 137 */ 138 typedef const char* (*getTopTypeSmallJsonFt)(smallJsont *self); 139 140 /** 141 * set top object type 142 * 143 * after smallJsont is initialized, it is empty and there is no top object, 144 * this function allocates the top object in self with default values 145 */ 146 typedef smallJsont* (*setTypeUndefinedSmallJsonFt)(smallJsont *self); 147 typedef smallJsont* (*setTypeBoolSmallJsonFt) (smallJsont *self); 148 typedef smallJsont* (*setTypeDoubleSmallJsonFt) (smallJsont *self); 149 typedef smallJsont* (*setTypeIntSmallJsonFt) (smallJsont *self); 150 typedef smallJsont* (*setTypeStringSmallJsonFt) (smallJsont *self); 151 typedef smallJsont* (*setTypeDictSmallJsonFt) (smallJsont *self); 152 typedef smallJsont* (*setTypeArraySmallJsonFt) (smallJsont *self); 153 154 /** 155 * set top object in self 156 * top of same type can be set multiple times 157 * 158 * \param 159 * value object to set in self 160 */ 161 typedef smallJsont* (*setTopSmallJsonFt) (smallJsont *self, baset *value); 162 typedef smallJsont* (*setTopBoolSmallJsonFt) (smallJsont *self, bool value); 163 typedef smallJsont* (*setTopDoubleSmallJsonFt) (smallJsont *self, double value); 164 typedef smallJsont* (*setTopIntSmallJsonFt) (smallJsont *self, int64_t value); 165 typedef smallJsont* (*setTopStringSmallJsonFt) (smallJsont *self, const char *value); 166 typedef smallJsont* (*setTopCharSmallJsonFt) (smallJsont *self, char c); 167 typedef smallJsont* (*setTopDictSmallJsonFt) (smallJsont *self, smallDictt *value); 168 typedef smallJsont* (*setTopArraySmallJsonFt) (smallJsont *self, smallArrayt *value); 169 typedef smallJsont* (*setTopArraycSmallJsonFt) (smallJsont *self, char **value); 170 typedef smallJsont* (*setTopCArraycSmallJsonFt) (smallJsont *self, const char **value); 171 typedef smallJsont* (*setTopSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 172 typedef smallJsont* (*setTopSmallDoubleSmallJsonFt)(smallJsont *self, smallDoublet *value); 173 typedef smallJsont* (*setTopSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 174 typedef smallJsont* (*setTopSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 175 typedef smallJsont* (*setTopSmallStringSmallJsonFt)(smallJsont *self, smallStringt *value); 176 177 /** 178 * set top object in self and free value container 179 * 180 * \param 181 * value object to set in self 182 */ 183 typedef smallJsont* (*setTopNFreeSmallJsonFt) (smallJsont *self, baset *value); 184 typedef smallJsont* (*setTopNFreeBoolSmallJsonFt) (smallJsont *self, bool value); 185 typedef smallJsont* (*setTopNFreeDoubleSmallJsonFt) (smallJsont *self, double value); 186 typedef smallJsont* (*setTopNFreeIntSmallJsonFt) (smallJsont *self, int64_t value); 187 typedef smallJsont* (*setTopNFreeStringSmallJsonFt) (smallJsont *self, char *value); 188 typedef smallJsont* (*setTopNFreeDictSmallJsonFt) (smallJsont *self, smallDictt *value); 189 typedef smallJsont* (*setTopNFreeArraySmallJsonFt) (smallJsont *self, smallArrayt *value); 190 typedef smallJsont* (*setTopNFreeArraycSmallJsonFt) (smallJsont *self, char **value); 191 typedef smallJsont* (*setTopNFreeSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 192 typedef smallJsont* (*setTopNFreeSmallDoubleSmallJsonFt)(smallJsont *self, smallDoublet *value); 193 typedef smallJsont* (*setTopNFreeSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 194 typedef smallJsont* (*setTopNFreeSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 195 typedef smallJsont* (*setTopNFreeSmallStringSmallJsonFt)(smallJsont *self, smallStringt *value); 196 197 /** 198 * copy array of 'size' to self 199 * NULL elements are not copied to the list 200 * 201 * \param 202 * array 203 * \param 204 * size number of elements in the array, size 0 means NULL terminated array 205 * \return 206 * list 207 * empty list when size is 0 208 * NULL when array is NULL 209 */ 210 typedef smallJsont* (*fromArraySmallJsonFt) (smallJsont *self, char **array, size_t size); 211 typedef smallJsont* (*fromCArraySmallJsonFt) (smallJsont *self, const char **array, size_t size); 212 typedef smallJsont* (*fromArrayNFreeSmallJsonFt)(smallJsont *self, char **array, size_t size); 213 214 /** 215 * convert array to dictionary 216 * 217 * The array must have the format: 218 * [[key(string), value], ...] 219 * 220 * Elements not in this format are not added to the dictionary 221 */ 222 typedef smallJsont* (*fromArrayDictSmallJsonFt) (smallJsont *self, smallArrayt *items); 223 224 /** 225 * convert dictionary to array 226 * 227 * Array format: 228 * [[key, value], ...] 229 */ 230 typedef smallArrayt* (*toArrayDictSmallJsonFt) (smallJsont *self); 231 232 /** 233 * get a baset object with the top object from self inside 234 * 235 * when the object is reallocated use setTop function to update the pointer in self 236 */ 237 typedef baset* (*getTopSmallJsonFt) (smallJsont *self); 238 typedef undefinedt* (*getTopUndefinedSmallJsonFt) (smallJsont *self); 239 typedef bool (*getTopBoolSmallJsonFt) (smallJsont *self); 240 typedef bool* (*getTopBoolPSmallJsonFt) (smallJsont *self); 241 typedef double (*getTopDoubleSmallJsonFt) (smallJsont *self); 242 typedef double* (*getTopDoublePSmallJsonFt) (smallJsont *self); 243 typedef int64_t (*getTopIntSmallJsonFt) (smallJsont *self); 244 typedef int64_t* (*getTopIntPSmallJsonFt) (smallJsont *self); 245 typedef int32_t (*getTopInt32SmallJsonFt) (smallJsont *self); 246 typedef int32_t* (*getTopInt32PSmallJsonFt) (smallJsont *self); 247 typedef uint64_t (*getTopUintSmallJsonFt) (smallJsont *self); 248 typedef uint64_t* (*getTopUintPSmallJsonFt) (smallJsont *self); 249 typedef uint32_t (*getTopUint32SmallJsonFt) (smallJsont *self); 250 typedef uint32_t* (*getTopUint32PSmallJsonFt) (smallJsont *self); 251 typedef char* (*getTopSSmallJsonFt) (smallJsont *self); 252 typedef smallDictt* (*getTopDictSmallJsonFt) (smallJsont *self); 253 typedef smallArrayt* (*getTopArraySmallJsonFt) (smallJsont *self); 254 typedef smallBoolt* (*getTopSmallBoolSmallJsonFt) (smallJsont *self); 255 typedef smallDoublet* (*getTopSmallDoubleSmallJsonFt)(smallJsont *self); 256 typedef smallIntt* (*getTopSmallIntSmallJsonFt) (smallJsont *self); 257 typedef smallStringt* (*getTopSmallStringSmallJsonFt)(smallJsont *self); 258 259 /** 260 * keyIs 261 * determine json key type: dictionary key, json path starting from an array or json path starting from a dictionary 262 * 263 * use the jsonPathResS[] array to convert the result to string (or use keyIsS to get the result as string directly) 264 * 265 * \param 266 * key any key or path in self 267 * \return 268 * key type (enum int) 269 * 0 (KEY_IS_NULL in enum) when key is NULL 270 */ 271 typedef jsonPathRest (*keyIsSmallJsonFt) (smallJsont *self, const char *key); 272 273 /** 274 * keyIs returning result as string 275 * determine json key type: dictionary key, json path starting from an array or json path starting from a dictionary 276 * 277 * \param 278 * key any key or path in self 279 * \return 280 * key type 281 * NULL when key is NULL 282 */ 283 typedef const char* (*keyIsSSmallJsonFt) (smallJsont *self, const char *key); 284 285 /** 286 * make json key 287 * escape " and \ characters and add quotes to prevent misinterpreting the key as a json path 288 * 289 * \param 290 * key key to transform 291 * \return 292 * new dictionary key (you must free this buffer) 293 * NULL when key is NULL 294 */ 295 typedef char* (*makeKeySmallJsonFt) (smallJsont *self, const char *key); 296 297 /** 298 * make json key 299 * escape " and \ characters and add quotes to prevent misinterpreting the key as a json path 300 * 301 * \param 302 * key pointer to key to transform (this parameter is reallocated) 303 * \return 304 * new dictionary key (you must free this buffer) 305 * NULL when key is NULL 306 */ 307 typedef char* (*iMakeKeySmallJsonFt) (smallJsont *self, char **key); 308 309 /** 310 * make json key 311 * escape " and \ characters and add quotes to prevent misinterpreting the key as a json path 312 * the result is stored dest, dest must be big enough (at least makeKeyLen+1) 313 * 314 * \param 315 * key key to transform 316 * \param 317 * dest result buffer 318 * \return 319 * dictionary key in dest 320 * NULL when key is NULL 321 */ 322 typedef char* (*bMakeKeySmallJsonFt) (smallJsont *self, char *dest, const char *key); 323 324 /** 325 * make json key 326 * escape " and \ characters and add quotes to prevent misinterpreting the key as a json path 327 * the result is stored dest, dest size must be big enough (at least makeKeyLen+1) 328 * 329 * \param 330 * key key to transform 331 * \param 332 * dest result buffer 333 * \param 334 * size dest buffer size 335 * \return 336 * dictionary key in dest 337 * NULL when key is NULL 338 */ 339 typedef char* (*bLMakeKeySmallJsonFt) (smallJsont *self, char *dest, size_t size, const char *key); 340 341 /** 342 * return key length after running makeKey 343 * 344 * \param 345 * key key to transform 346 * \return 347 * dictionary key length 348 * 0 when key is NULL 349 */ 350 typedef size_t (*makeKeyLenSmallJsonFt)(smallJsont *self, const char *key); 351 352 /** 353 * set element 354 * 355 * When the sObject pointer is updated by realloc, the sObject 356 * pointer in the smallArray has to be updated with setP. 357 * The operations reallocating the sObjects are: 358 * smallDict: push, set, trim, merge, append 359 * smallArray: push, prepend 360 * smallBytes: push, pushBuffer 361 * smallJson: push, set 362 * smallString: append, prepend, replace, intTo, insert, color, readFile 363 * 364 * The object is duplicated for: 365 * char * 366 * 367 * \param 368 * key dictionary key 369 * \param 370 * value an object 371 */ 372 typedef smallJsont* (*setSmallJsonFt) (smallJsont *self, const char *key, baset *value); 373 typedef smallJsont* (*setUndefinedSmallJsonFt)(smallJsont *self, const char *key); 374 typedef smallJsont* (*setBoolSmallJsonFt) (smallJsont *self, const char *key, bool value); 375 typedef smallJsont* (*setDoubleSmallJsonFt) (smallJsont *self, const char *key, double value); 376 typedef smallJsont* (*setIntSmallJsonFt) (smallJsont *self, const char *key, int64_t value); 377 typedef smallJsont* (*setSSmallJsonFt) (smallJsont *self, const char *key, const char *string); 378 typedef smallJsont* (*setCharSmallJsonFt) (smallJsont *self, const char *key, char c); 379 typedef smallJsont* (*setDictSmallJsonFt) (smallJsont *self, const char *key, smallDictt *dict); 380 typedef smallJsont* (*setArraySmallJsonFt) (smallJsont *self, const char *key, smallArrayt *array); 381 typedef smallJsont* (*setArraycSmallJsonFt) (smallJsont *self, const char *key, char **array); 382 typedef smallJsont* (*setCArraycSmallJsonFt) (smallJsont *self, const char *key, const char **array); 383 typedef smallJsont* (*setSmallBoolSmallJsonFt) (smallJsont *self, const char *key, smallBoolt *value); 384 typedef smallJsont* (*setSmallBytesSmallJsonFt) (smallJsont *self, const char *key, smallBytest *value); 385 typedef smallJsont* (*setSmallDoubleSmallJsonFt) (smallJsont *self, const char *key, smallDoublet *value); 386 typedef smallJsont* (*setSmallIntSmallJsonFt) (smallJsont *self, const char *key, smallIntt *value); 387 typedef smallJsont* (*setSmallJsonSmallJsonFt) (smallJsont *self, const char *key, smallJsont *value); 388 typedef smallJsont* (*setSmallStringSmallJsonFt) (smallJsont *self, const char *key, smallStringt *string); 389 typedef smallJsont* (*setSmallContainerSmallJsonFt)(smallJsont *self, const char *key, smallContainert *container); 390 391 /** 392 * set element and free 393 * 394 * value is freed at the end of the function 395 * Example: when setting a string is copied to a smallStringt and then freed 396 * 397 * \param 398 * key smallDictionary key 399 * \param 400 * value an object 401 */ 402 typedef smallJsont* (*setNFreeSmallJsonFt) (smallJsont *self, const char *key, baset *value); 403 typedef smallJsont* (*setNFreeUndefinedSmallJsonFt)(smallJsont *self, const char *key, undefinedt *undefined); 404 typedef smallJsont* (*setNFreeSSmallJsonFt) (smallJsont *self, const char *key, char *string); 405 typedef smallJsont* (*setNFreeDictSmallJsonFt) (smallJsont *self, const char *key, smallDictt *dict); 406 typedef smallJsont* (*setNFreeArraySmallJsonFt) (smallJsont *self, const char *key, smallArrayt *array); 407 typedef smallJsont* (*setNFreeArraycSmallJsonFt) (smallJsont *self, const char *key, char **array); 408 typedef smallJsont* (*setNFreeSmallBoolSmallJsonFt) (smallJsont *self, const char *key, smallBoolt *value); 409 typedef smallJsont* (*setNFreeSmallBytesSmallJsonFt) (smallJsont *self, const char *key, smallBytest *value); 410 typedef smallJsont* (*setNFreeSmallDoubleSmallJsonFt) (smallJsont *self, const char *key, smallDoublet *value); 411 typedef smallJsont* (*setNFreeSmallIntSmallJsonFt) (smallJsont *self, const char *key, smallIntt *value); 412 typedef smallJsont* (*setNFreeSmallJsonSmallJsonFt) (smallJsont *self, const char *key, smallJsont *value); 413 typedef smallJsont* (*setNFreeSmallStringSmallJsonFt) (smallJsont *self, const char *key, smallStringt *string); 414 typedef smallJsont* (*setNFreeSmallContainerSmallJsonFt)(smallJsont *self, const char *key, smallContainert *container); 415 416 /** 417 * set pointer in element 418 * 419 * \param 420 * key smallDictionary key 421 * \param 422 * value an object 423 */ 424 typedef smallJsont* (*setPArraySmallJsonFt) (smallJsont *self, const char *key, smallArrayt *array); 425 typedef smallJsont* (*setPDictSmallJsonFt) (smallJsont *self, const char *key, smallDictt *dict); 426 typedef smallJsont* (*setPSmallJsonSmallJsonFt) (smallJsont *self, const char *key, smallJsont *value); 427 typedef smallJsont* (*setPSmallStringSmallJsonFt) (smallJsont *self, const char *key, smallStringt *string); 428 typedef smallJsont* (*setNFreePArraySmallJsonFt) (smallJsont *self, const char *key, smallArrayt *array); 429 typedef smallJsont* (*setNFreePDictSmallJsonFt) (smallJsont *self, const char *key, smallDictt *dict); 430 typedef smallJsont* (*setNFreePSmallJsonSmallJsonFt) (smallJsont *self, const char *key, smallJsont *value); 431 typedef smallJsont* (*setNFreePSmallStringSmallJsonFt)(smallJsont *self, const char *key, smallStringt *string); 432 433 /** 434 * store object at given index (free already existing elements when baset *value is NULL) 435 * index can be negative 436 * 437 * When the sObject pointer is updated by realloc, the sObject 438 * pointer in the smallArray has to be updated with setP. 439 * The operations reallocating the sObjects are: 440 * smallDict: push, set, trim, merge, append 441 * smallArray: push, prepend 442 * smallBytes: push, pushBuffer 443 * smallJson: push, set 444 * smallString: append, prepend, replace, intTo, insert, color, readFile 445 * 446 * The object is duplicated for: 447 * char * 448 * 449 * \param 450 * index: index in array, must be inside the array 451 * string 452 * \return 453 * 0 success 454 * -1 error 455 * 456 * Does nothing when: 457 * when array is NULL, index is not set correctly or s is NULL 458 */ 459 typedef smallJsont* (*setAtSmallJsonFt) (smallJsont *self, int64_t index, baset *value); 460 typedef smallJsont* (*setAtUndefinedSmallJsonFt)(smallJsont *self, int64_t index); 461 typedef smallJsont* (*setAtBoolSmallJsonFt) (smallJsont *self, int64_t index, bool value); 462 typedef smallJsont* (*setAtDoubleSmallJsonFt) (smallJsont *self, int64_t index, double value); 463 typedef smallJsont* (*setAtIntSmallJsonFt) (smallJsont *self, int64_t index, int64_t value); 464 typedef smallJsont* (*setAtSSmallJsonFt) (smallJsont *self, int64_t index, const char *string); 465 typedef smallJsont* (*setAtCharSmallJsonFt) (smallJsont *self, int64_t index, char c); 466 typedef smallJsont* (*setAtDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *dict); 467 typedef smallJsont* (*setAtArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *array); 468 typedef smallJsont* (*setAtArraycSmallJsonFt) (smallJsont *self, int64_t index, char **array); 469 typedef smallJsont* (*setAtCArraycSmallJsonFt) (smallJsont *self, int64_t index, const char **array); 470 typedef smallJsont* (*setAtSmallBoolSmallJsonFt) (smallJsont *self, int64_t index, smallBoolt *value); 471 typedef smallJsont* (*setAtSmallBytesSmallJsonFt) (smallJsont *self, int64_t index, smallBytest *value); 472 typedef smallJsont* (*setAtSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index, smallDoublet *value); 473 typedef smallJsont* (*setAtSmallIntSmallJsonFt) (smallJsont *self, int64_t index, smallIntt *value); 474 typedef smallJsont* (*setAtSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *value); 475 typedef smallJsont* (*setAtSmallStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *string); 476 typedef smallJsont* (*setAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container); 477 478 /** 479 * store object at given index (free already existing elements) 480 * index can be negative 481 * 482 * the object parameter is freed 483 * 484 * \param 485 * index: index in array, must be inside the array 486 * string 487 * \return 488 * 0 success 489 * -1 error 490 * 491 * Does nothing when: 492 * when array is NULL, index is not set correctly or s is NULL 493 */ 494 typedef smallJsont* (*setAtNFreeSmallJsonFt) (smallJsont *self, int64_t index, baset *value); 495 typedef smallJsont* (*setAtNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined); 496 typedef smallJsont* (*setAtNFreeSSmallJsonFt) (smallJsont *self, int64_t index, char *string); 497 typedef smallJsont* (*setAtNFreeDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *dict); 498 typedef smallJsont* (*setAtNFreeArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *array); 499 typedef smallJsont* (*setAtNFreeArraycSmallJsonFt) (smallJsont *self, int64_t index, char **array); 500 typedef smallJsont* (*setAtNFreeSmallBoolSmallJsonFt) (smallJsont *self, int64_t index, smallBoolt *value); 501 typedef smallJsont* (*setAtNFreeSmallBytesSmallJsonFt) (smallJsont *self, int64_t index, smallBytest *value); 502 typedef smallJsont* (*setAtNFreeSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index, smallDoublet *value); 503 typedef smallJsont* (*setAtNFreeSmallIntSmallJsonFt) (smallJsont *self, int64_t index, smallIntt *value); 504 typedef smallJsont* (*setAtNFreeSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *value); 505 typedef smallJsont* (*setAtNFreeSmallStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *string); 506 typedef smallJsont* (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container); 507 508 /** 509 * store pointer at given index (existing element is not freed) 510 * index can be negative 511 * 512 * \param 513 * index: index in array, must be inside the array 514 * string 515 * \return 516 * 0 success 517 * -1 error 518 * 519 * Does nothing when: 520 * when array is NULL, index is not set correctly or s is NULL 521 */ 522 typedef smallJsont* (*setPAtArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *array); 523 typedef smallJsont* (*setPAtDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *dict); 524 typedef smallJsont* (*setPAtSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *value); 525 typedef smallJsont* (*setPAtSmallStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *string); 526 typedef smallJsont* (*setPAtNFreeArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *array); 527 typedef smallJsont* (*setPAtNFreeDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *dict); 528 typedef smallJsont* (*setPAtNFreeSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *value); 529 typedef smallJsont* (*setPAtNFreeSmallStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *string); 530 531 /** 532 * get element 533 * 534 * \param 535 * key dictionary key 536 * \return 537 * object or NULL 538 */ 539 typedef baset* (*getSmallJsonFt) (smallJsont *self, const char *key); 540 typedef undefinedt* (*getUndefinedSmallJsonFt) (smallJsont *self, const char *key); 541 typedef bool (*getBoolSmallJsonFt) (smallJsont *self, const char *key); 542 typedef bool* (*getBoolPSmallJsonFt) (smallJsont *self, const char *key); 543 typedef double (*getDoubleSmallJsonFt) (smallJsont *self, const char *key); 544 typedef double* (*getDoublePSmallJsonFt) (smallJsont *self, const char *key); 545 typedef int64_t (*getIntSmallJsonFt) (smallJsont *self, const char *key); 546 typedef int64_t* (*getIntPSmallJsonFt) (smallJsont *self, const char *key); 547 typedef int32_t (*getInt32SmallJsonFt) (smallJsont *self, const char *key); 548 typedef int32_t* (*getInt32PSmallJsonFt) (smallJsont *self, const char *key); 549 typedef uint64_t (*getUintSmallJsonFt) (smallJsont *self, const char *key); 550 typedef uint64_t* (*getUintPSmallJsonFt) (smallJsont *self, const char *key); 551 typedef uint32_t (*getUint32SmallJsonFt) (smallJsont *self, const char *key); 552 typedef uint32_t* (*getUint32PSmallJsonFt) (smallJsont *self, const char *key); 553 typedef char* (*getSSmallJsonFt) (smallJsont *self, const char *key); 554 typedef smallDictt* (*getDictSmallJsonFt) (smallJsont *self, const char *key); 555 typedef smallArrayt* (*getArraySmallJsonFt) (smallJsont *self, const char *key); 556 typedef smallBoolt* (*getSmallBoolSmallJsonFt) (smallJsont *self, const char *key); 557 typedef smallBytest* (*getSmallBytesSmallJsonFt) (smallJsont *self, const char *key); 558 typedef smallDoublet* (*getSmallDoubleSmallJsonFt) (smallJsont *self, const char *key); 559 typedef smallIntt* (*getSmallIntSmallJsonFt) (smallJsont *self, const char *key); 560 typedef smallJsont* (*getSmallJsonSmallJsonFt) (smallJsont *self, const char *key); 561 typedef smallStringt* (*getSmallStringSmallJsonFt) (smallJsont *self, const char *key); 562 typedef void* (*getVoidSmallJsonFt) (smallJsont *self, const char *key); 563 typedef smallContainert* (*getSmallContainerSmallJsonFt)(smallJsont *self, const char *key); 564 565 /** 566 * get duplicated object 567 * 568 * \param 569 * key dictionary key 570 * \return 571 * object or NULL 572 */ 573 typedef baset* (*getNDupSmallJsonFt) (smallJsont *self, const char *key); 574 typedef undefinedt* (*getNDupUndefinedSmallJsonFt) (smallJsont *self, const char *key); 575 typedef bool (*getNDupBoolSmallJsonFt) (smallJsont *self, const char *key); 576 typedef double (*getNDupDoubleSmallJsonFt) (smallJsont *self, const char *key); 577 typedef int64_t (*getNDupIntSmallJsonFt) (smallJsont *self, const char *key); 578 typedef int32_t (*getNDupInt32SmallJsonFt) (smallJsont *self, const char *key); 579 typedef uint64_t (*getNDupUintSmallJsonFt) (smallJsont *self, const char *key); 580 typedef uint32_t (*getNDupUint32SmallJsonFt) (smallJsont *self, const char *key); 581 typedef char* (*getNDupSSmallJsonFt) (smallJsont *self, const char *key); 582 typedef smallDictt* (*getNDupDictSmallJsonFt) (smallJsont *self, const char *key); 583 typedef smallArrayt* (*getNDupArraySmallJsonFt) (smallJsont *self, const char *key); 584 typedef smallBoolt* (*getNDupSmallBoolSmallJsonFt) (smallJsont *self, const char *key); 585 typedef smallBytest* (*getNDupSmallBytesSmallJsonFt) (smallJsont *self, const char *key); 586 typedef smallDoublet* (*getNDupSmallDoubleSmallJsonFt) (smallJsont *self, const char *key); 587 typedef smallIntt* (*getNDupSmallIntSmallJsonFt) (smallJsont *self, const char *key); 588 typedef smallJsont* (*getNDupSmallJsonSmallJsonFt) (smallJsont *self, const char *key); 589 typedef smallStringt* (*getNDupSmallStringSmallJsonFt) (smallJsont *self, const char *key); 590 typedef void* (*getNDupVoidSmallJsonFt) (smallJsont *self, const char *key); 591 typedef smallContainert* (*getNDupSmallContainerSmallJsonFt)(smallJsont *self, const char *key); 592 593 /** 594 * get object at index 595 * index can be negative 596 * 597 * \param 598 * index: index in array, must be inside the array 599 * \return 600 * pointer to object 601 * NULL when array is NULL or index is not set correctly 602 */ 603 typedef baset* (*getAtSmallJsonFt) (smallJsont *self, int64_t index); 604 typedef undefinedt* (*getAtUndefinedSmallJsonFt) (smallJsont *self, int64_t index); 605 typedef bool (*getAtBoolSmallJsonFt) (smallJsont *self, int64_t index); 606 typedef bool* (*getAtBoolPSmallJsonFt) (smallJsont *self, int64_t index); 607 typedef double (*getAtDoubleSmallJsonFt) (smallJsont *self, int64_t index); 608 typedef double* (*getAtDoublePSmallJsonFt) (smallJsont *self, int64_t index); 609 typedef int64_t (*getAtIntSmallJsonFt) (smallJsont *self, int64_t index); 610 typedef int64_t* (*getAtIntPSmallJsonFt) (smallJsont *self, int64_t index); 611 typedef int32_t (*getAtInt32SmallJsonFt) (smallJsont *self, int64_t index); 612 typedef int32_t* (*getAtInt32PSmallJsonFt) (smallJsont *self, int64_t index); 613 typedef uint64_t (*getAtUintSmallJsonFt) (smallJsont *self, int64_t index); 614 typedef uint64_t* (*getAtUintPSmallJsonFt) (smallJsont *self, int64_t index); 615 typedef uint32_t (*getAtUint32SmallJsonFt) (smallJsont *self, int64_t index); 616 typedef uint32_t* (*getAtUint32PSmallJsonFt) (smallJsont *self, int64_t index); 617 typedef char* (*getAtSSmallJsonFt) (smallJsont *self, int64_t index); 618 typedef smallDictt* (*getAtDictSmallJsonFt) (smallJsont *self, int64_t index); 619 typedef smallArrayt* (*getAtArraySmallJsonFt) (smallJsont *self, int64_t index); 620 typedef smallBoolt* (*getAtSmallBoolSmallJsonFt) (smallJsont *self, int64_t index); 621 typedef smallBytest* (*getAtSmallBytesSmallJsonFt) (smallJsont *self, int64_t index); 622 typedef smallDoublet* (*getAtSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index); 623 typedef smallIntt* (*getAtSmallIntSmallJsonFt) (smallJsont *self, int64_t index); 624 typedef smallJsont* (*getAtSmallJsonSmallJsonFt) (smallJsont *self, int64_t index); 625 typedef smallStringt* (*getAtSmallStringSmallJsonFt) (smallJsont *self, int64_t index); 626 typedef void* (*getAtVoidSmallJsonFt) (smallJsont *self, int64_t index); 627 typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index); 628 629 /** 630 * get duplicated object at index 631 * index can be negative 632 * 633 * \param 634 * index: index in array, must be inside the array 635 * \return 636 * duplicated object 637 * NULL when array is NULL or index is not set correctly 638 */ 639 typedef baset* (*getAtNDupSmallJsonFt) (smallJsont *self, int64_t index); 640 typedef undefinedt* (*getAtNDupUndefinedSmallJsonFt) (smallJsont *self, int64_t index); 641 typedef bool (*getAtNDupBoolSmallJsonFt) (smallJsont *self, int64_t index); 642 typedef double (*getAtNDupDoubleSmallJsonFt) (smallJsont *self, int64_t index); 643 typedef int64_t (*getAtNDupIntSmallJsonFt) (smallJsont *self, int64_t index); 644 typedef int32_t (*getAtNDupInt32SmallJsonFt) (smallJsont *self, int64_t index); 645 typedef uint64_t (*getAtNDupUintSmallJsonFt) (smallJsont *self, int64_t index); 646 typedef uint32_t (*getAtNDupUint32SmallJsonFt) (smallJsont *self, int64_t index); 647 typedef char* (*getAtNDupSSmallJsonFt) (smallJsont *self, int64_t index); 648 typedef smallDictt* (*getAtNDupDictSmallJsonFt) (smallJsont *self, int64_t index); 649 typedef smallArrayt* (*getAtNDupArraySmallJsonFt) (smallJsont *self, int64_t index); 650 typedef smallBoolt* (*getAtNDupSmallBoolSmallJsonFt) (smallJsont *self, int64_t index); 651 typedef smallBytest* (*getAtNDupSmallBytesSmallJsonFt) (smallJsont *self, int64_t index); 652 typedef smallDoublet* (*getAtNDupSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index); 653 typedef smallIntt* (*getAtNDupSmallIntSmallJsonFt) (smallJsont *self, int64_t index); 654 typedef smallJsont* (*getAtNDupSmallJsonSmallJsonFt) (smallJsont *self, int64_t index); 655 typedef smallStringt* (*getAtNDupSmallStringSmallJsonFt) (smallJsont *self, int64_t index); 656 typedef void* (*getAtNDupVoidSmallJsonFt) (smallJsont *self, int64_t index); 657 typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self, int64_t index); 658 659 /** 660 * get number 661 * 662 * if the element is a double, its value is returned as is 663 * if the element is an int, its value is converted to double 664 * if the element is not a number, 0 is returned 665 * 666 * \param 667 * key dictionary key 668 * \return 669 * double type number or 0 670 */ 671 typedef double (*getNumSmallJsonFt) (smallJsont *self, const char *key); 672 typedef double (*getNumAtSmallJsonFt) (smallJsont *self, int64_t index); 673 674 /** 675 * delete element 676 * 677 * free element sObject for given key 678 * this function is to be used before dispose to free some elements 679 * For example: 680 * createSmallJson(d); 681 * smallStringt *s = allocG("the element to keep"); 682 * setG(d,"0", "The element to free"); 683 * setG(d,"1", s); 684 * 685 * The dictionary a is: {"0":"The element to free", "1":"the element to keep"} 686 * 687 * To dispose d and be able to free all objects, the element for key "0" must be freed with delElem 688 * The sObject for key "1" and the one in s are identical, so the element 1 is freed when s is freed 689 * 690 * \param 691 * key smallDictionary key 692 */ 693 typedef smallJsont* (*delElemSmallJsonFt) (smallJsont *self, const char *key); 694 695 /** 696 * remove (free) elements from start and end in self 697 * negative indexes are allowed 698 * 699 * \param 700 * start index, must be in the array 701 * end index, must be in the array 702 * \return 703 * sliced array 704 * array copy when start=end or when start and end are not set correctly 705 * NULL when array is empty 706 * NULL when array is NULL or when end is under start 707 * 0 success 708 * -1 error 709 */ 710 typedef smallJsont* (*delSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 711 712 /** 713 * delete element 714 * 715 * free element sObject at index 716 * this function is to be used before dispose to free some elements 717 * For example: 718 * createSmallJson(a); 719 * smallStringt *s = allocG("the element to keep"); 720 * pushG(a, "The element to free"); 721 * pushG(a, s); 722 * 723 * The json a is: ["The element to free", "the element to keep"] 724 * 725 * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem 726 * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed 727 */ 728 typedef smallJsont* (*delElemIndexSmallJsonFt) (smallJsont *self, int64_t index); 729 730 /** 731 * remove without freeing element 732 * 733 * remove element sObject for given key 734 * 735 * Example: 736 * cleanAllocateSmallString(S); 737 * setValG(S, "sString object"); 738 * cleanAllocateSmallJson(d); 739 * // set an object shared with another container in the json d 740 * // "sString object" is in both container S and d 741 * setG(d, "key1" ,S); 742 * setG(d, "key2", "another string"); 743 * // the program deletes the element for "key1" 744 * // to do so, it uses removeElemG since S will free the sString object 745 * removeElemG(d, "key1"); 746 * 747 * \param 748 * key smallDictionary key 749 */ 750 typedef smallJsont* (*removeElemSmallJsonFt) (smallJsont *self, const char *key); 751 752 /** 753 * remove without freeing elements from start and end in self 754 * negative indexes are allowed 755 * 756 * \param 757 * start index, must be in the array 758 * end index, must be in the array 759 * \return 760 * sliced array 761 * array copy when start=end or when start and end are not set correctly 762 * NULL when array is empty 763 * NULL when array is NULL or when end is under start 764 * 0 success 765 * -1 error 766 */ 767 typedef smallJsont* (*removeSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 768 769 /** 770 * remove without freeing element 771 * 772 * remove element sObject at index 773 * 774 * Example: 775 * cleanAllocateSmallString(S); 776 * setValG(S, "sString object"); 777 * cleanAllocateSmallJson(a); 778 * // set an object shared with another container in the json a 779 * // "sString object" is in both container S and a 780 * pushG(a, S); 781 * pushG(a, "another string"); 782 * // the program deletes element 0 in json a 783 * // to do so, it uses removeElemG since S will free the sString object 784 * removeElemG(a, 0); 785 */ 786 typedef smallJsont* (*removeElemIndexSmallJsonFt) (smallJsont *self, int64_t index); 787 788 /** 789 * push value to json 790 * 791 * When the sObject pointer is updated by realloc, the sObject 792 * pointer in the smallArray has to be updated with setP. 793 * The operations reallocating the sObjects are: 794 * smallDict: push, set, trim, merge, append 795 * smallArray: push, prepend 796 * smallBytes: push, pushBuffer 797 * smallJson: push, set 798 * smallString: append, prepend, replace, intTo, insert, color, readFile 799 * 800 * The object is duplicated for: 801 * char * 802 * 803 */ 804 typedef smallJsont* (*pushSmallJsonFt) (smallJsont *self, baset *value); 805 typedef smallJsont* (*pushUndefinedSmallJsonFt)(smallJsont *self); 806 typedef smallJsont* (*pushBoolSmallJsonFt) (smallJsont *self, bool value); 807 typedef smallJsont* (*pushDoubleSmallJsonFt) (smallJsont *self, double value); 808 typedef smallJsont* (*pushIntSmallJsonFt) (smallJsont *self, int64_t value); 809 typedef smallJsont* (*pushSSmallJsonFt) (smallJsont *self, const char *string); 810 typedef smallJsont* (*pushCharSmallJsonFt) (smallJsont *self, char c); 811 typedef smallJsont* (*pushDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 812 typedef smallJsont* (*pushArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 813 typedef smallJsont* (*pushArraycSmallJsonFt) (smallJsont *self, char **array); 814 typedef smallJsont* (*pushCArraycSmallJsonFt) (smallJsont *self, const char **array); 815 typedef smallJsont* (*pushSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 816 typedef smallJsont* (*pushSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 817 typedef smallJsont* (*pushSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 818 typedef smallJsont* (*pushSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 819 typedef smallJsont* (*pushSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 820 typedef smallJsont* (*pushSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 821 typedef smallJsont* (*pushSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 822 823 /** 824 * push element and free 825 * 826 * value container is freed at the end of the function 827 * Example: when setting a smallString, it is copied to an sStringt and then the object is freed 828 * 829 * \param 830 * value an object 831 */ 832 typedef smallJsont* (*pushNFreeSmallJsonFt) (smallJsont *self, baset *value); 833 typedef smallJsont* (*pushNFreeUndefinedSmallJsonFt) (smallJsont *self, undefinedt *undefined); 834 typedef smallJsont* (*pushNFreeSSmallJsonFt) (smallJsont *self, char *string); 835 typedef smallJsont* (*pushNFreeDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 836 typedef smallJsont* (*pushNFreeArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 837 typedef smallJsont* (*pushNFreeArraycSmallJsonFt) (smallJsont *self, char **array); 838 typedef smallJsont* (*pushNFreeSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 839 typedef smallJsont* (*pushNFreeSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 840 typedef smallJsont* (*pushNFreeSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 841 typedef smallJsont* (*pushNFreeSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 842 typedef smallJsont* (*pushNFreeSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 843 typedef smallJsont* (*pushNFreeSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 844 typedef smallJsont* (*pushNFreeSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 845 846 /** 847 * push many elements 848 * 849 * \param 850 * arbitrary list of smallObject elements seperated by commas 851 */ 852 typedef smallJsont* (*pushManySmallJsonFt) (smallJsont *self, ...); 853 854 /** 855 * push many string elements 856 * 857 * \param 858 * arbitrary list of char* string elements seperated by commas 859 */ 860 typedef smallJsont* (*pushManySSmallJsonFt) (smallJsont *self, ...); 861 862 /** 863 * push many elements and free 864 * 865 * \param 866 * arbitrary list of smallObject elements seperated by commas 867 */ 868 typedef smallJsont* (*pushNFreeManySmallJsonFt) (smallJsont *self, ...); 869 870 /** 871 * push many string elements and free 872 * 873 * \param 874 * arbitrary list of char* string elements seperated by commas 875 */ 876 typedef smallJsont* (*pushNFreeManySSmallJsonFt)(smallJsont *self, ...); 877 878 /** 879 * pop object 880 * return last object from list and remove last element from the list 881 * 882 * \return 883 * last object pointer 884 * NULL when the list is NULL or empty (first element is NULL) 885 */ 886 typedef baset* (*popSmallJsonFt) (smallJsont *self); 887 typedef undefinedt* (*popUndefinedSmallJsonFt) (smallJsont *self); 888 typedef bool (*popBoolSmallJsonFt) (smallJsont *self); 889 typedef double (*popDoubleSmallJsonFt) (smallJsont *self); 890 typedef int64_t (*popIntSmallJsonFt) (smallJsont *self); 891 typedef int32_t (*popInt32SmallJsonFt) (smallJsont *self); 892 typedef uint64_t (*popUintSmallJsonFt) (smallJsont *self); 893 typedef uint32_t (*popUint32SmallJsonFt) (smallJsont *self); 894 typedef char* (*popSSmallJsonFt) (smallJsont *self); 895 typedef smallDictt* (*popDictSmallJsonFt) (smallJsont *self); 896 typedef smallArrayt* (*popArraySmallJsonFt) (smallJsont *self); 897 typedef smallBoolt* (*popSmallBoolSmallJsonFt) (smallJsont *self); 898 typedef smallBytest* (*popSmallBytesSmallJsonFt) (smallJsont *self); 899 typedef smallDoublet* (*popSmallDoubleSmallJsonFt) (smallJsont *self); 900 typedef smallIntt* (*popSmallIntSmallJsonFt) (smallJsont *self); 901 typedef smallJsont* (*popSmallJsonSmallJsonFt) (smallJsont *self); 902 typedef smallStringt* (*popSmallStringSmallJsonFt) (smallJsont *self); 903 typedef void* (*popVoidSmallJsonFt) (smallJsont *self); 904 typedef smallContainert* (*popSmallContainerSmallJsonFt)(smallJsont *self); 905 906 /** 907 * pop number 908 * 909 * if the element is a double, its value is returned as is 910 * if the element is an int, its value is converted to double 911 * if the element is not a number, 0 is returned 912 * 913 * \return 914 * double type number or 0 915 */ 916 typedef double (*popNumSmallJsonFt) (smallJsont *self); 917 918 /** 919 * prepend object 920 * append object pointer at the beginning of the list 921 * when value is NULL, the operation is canceled 922 * 923 * When the sObject pointer is updated by realloc, the sObject 924 * pointer in the smallArray has to be updated with setP. 925 * The operations reallocating the sObjects are: 926 * smallDict: push, set, trim, merge, append 927 * smallArray: push, prepend 928 * smallBytes: push, pushBuffer 929 * smallJson: push, set 930 * smallString: append, prepend, replace, intTo, insert, color, readFile 931 * 932 * The object is duplicated for: 933 * char * 934 * 935 * \param 936 * value string to prepend 937 * \return 938 * self 939 */ 940 typedef smallJsont* (*prependSmallJsonFt) (smallJsont *self, baset *value); 941 typedef smallJsont* (*prependUndefinedSmallJsonFt) (smallJsont *self); 942 typedef smallJsont* (*prependBoolSmallJsonFt) (smallJsont *self, bool value); 943 typedef smallJsont* (*prependDoubleSmallJsonFt) (smallJsont *self, double value); 944 typedef smallJsont* (*prependIntSmallJsonFt) (smallJsont *self, int64_t value); 945 typedef smallJsont* (*prependSSmallJsonFt) (smallJsont *self, const char *string); 946 typedef smallJsont* (*prependCharSmallJsonFt) (smallJsont *self, char c); 947 typedef smallJsont* (*prependDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 948 typedef smallJsont* (*prependArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 949 typedef smallJsont* (*prependArraycSmallJsonFt) (smallJsont *self, char **array); 950 typedef smallJsont* (*prependCArraycSmallJsonFt) (smallJsont *self, const char **array); 951 typedef smallJsont* (*prependSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 952 typedef smallJsont* (*prependSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 953 typedef smallJsont* (*prependSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 954 typedef smallJsont* (*prependSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 955 typedef smallJsont* (*prependSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 956 typedef smallJsont* (*prependSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 957 typedef smallJsont* (*prependSmallContainerSmallJsonFt) (smallJsont *self, smallContainert *container); 958 959 typedef smallJsont* (*prependNFreeSmallJsonFt) (smallJsont *self, baset *value); 960 typedef smallJsont* (*prependNFreeUndefinedSmallJsonFt) (smallJsont *self, undefinedt *undefined); 961 typedef smallJsont* (*prependNFreeSSmallJsonFt) (smallJsont *self, char *string); 962 typedef smallJsont* (*prependNFreeDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 963 typedef smallJsont* (*prependNFreeArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 964 typedef smallJsont* (*prependNFreeArraycSmallJsonFt) (smallJsont *self, char **array); 965 typedef smallJsont* (*prependNFreeSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 966 typedef smallJsont* (*prependNFreeSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 967 typedef smallJsont* (*prependNFreeSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 968 typedef smallJsont* (*prependNFreeSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 969 typedef smallJsont* (*prependNFreeSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 970 typedef smallJsont* (*prependNFreeSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 971 typedef smallJsont* (*prependNFreeSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 972 973 /** 974 * dequeue object 975 * return first object from list and remove it from the list 976 * 977 * \return 978 * first object 979 * NULL when the list is NULL or empty (first element is NULL) 980 */ 981 typedef baset* (*dequeueSmallJsonFt) (smallJsont *self); 982 typedef undefinedt* (*dequeueUndefinedSmallJsonFt) (smallJsont *self); 983 typedef bool (*dequeueBoolSmallJsonFt) (smallJsont *self); 984 typedef double (*dequeueDoubleSmallJsonFt) (smallJsont *self); 985 typedef int64_t (*dequeueIntSmallJsonFt) (smallJsont *self); 986 typedef int32_t (*dequeueInt32SmallJsonFt) (smallJsont *self); 987 typedef uint64_t (*dequeueUintSmallJsonFt) (smallJsont *self); 988 typedef uint32_t (*dequeueUint32SmallJsonFt) (smallJsont *self); 989 typedef char* (*dequeueSSmallJsonFt) (smallJsont *self); 990 typedef smallDictt* (*dequeueDictSmallJsonFt) (smallJsont *self); 991 typedef smallArrayt* (*dequeueArraySmallJsonFt) (smallJsont *self); 992 typedef smallBoolt* (*dequeueSmallBoolSmallJsonFt) (smallJsont *self); 993 typedef smallBytest* (*dequeueSmallBytesSmallJsonFt) (smallJsont *self); 994 typedef smallDoublet* (*dequeueSmallDoubleSmallJsonFt) (smallJsont *self); 995 typedef smallIntt* (*dequeueSmallIntSmallJsonFt) (smallJsont *self); 996 typedef smallJsont* (*dequeueSmallJsonSmallJsonFt) (smallJsont *self); 997 typedef smallStringt* (*dequeueSmallStringSmallJsonFt) (smallJsont *self); 998 typedef void* (*dequeueVoidSmallJsonFt) (smallJsont *self); 999 typedef smallContainert* (*dequeueSmallContainerSmallJsonFt)(smallJsont *self); 1000 1001 /** 1002 * dequeue number 1003 * 1004 * if the element is a double, its value is returned as is 1005 * if the element is an int, its value is converted to double 1006 * if the element is not a number, 0 is returned 1007 * 1008 * \return 1009 * double type number or 0 1010 */ 1011 typedef double (*dequeueNumSmallJsonFt) (smallJsont *self); 1012 1013 /** 1014 * reverse list, the last element is the first element of the list 1015 * 1016 * \return 1017 * reversed list 1018 * nothing when list is NULL 1019 * 0 success 1020 * -1 error 1021 */ 1022 typedef smallJsont* (*reverseSmallJsonFt) (smallJsont *self); 1023 1024 /** 1025 * cat json arrays 1026 * 1027 * append all arrays in the list to self 1028 * 1029 * \param 1030 * arbitrary list of smallArrays seperated by commas 1031 */ 1032 typedef smallJsont* (*catSmallJsonFt) (smallJsont *self, ...); 1033 1034 /** 1035 * merge override - already existing values are replaced 1036 */ 1037 typedef smallJsont* (*mergeDictSmallJsonFt) (smallJsont *self, smallDictt *smallDict); 1038 typedef smallJsont* (*mergeDictNSmashSmallJsonFt) (smallJsont *self, smallDictt *smallDict); 1039 typedef smallJsont* (*mergeSmallJsonFt) (smallJsont *self, smallJsont *smallJson); 1040 typedef smallJsont* (*mergeNSmashSmallJsonFt) (smallJsont *self, smallJsont *smallJson); 1041 1042 /** 1043 * append array at the end of self by copying the pointers 1044 * from array to self. 1045 * After this function, free array with dispose/smash instead of free/terminate 1046 * 1047 * \param 1048 * array 1049 * \return 1050 * self and array in self 1051 * self not modified when self and array are NULL 1052 * or when self is identical to array (same pointers) 1053 * 0 success 1054 * -1 error 1055 */ 1056 typedef smallJsont* (*appendSmallJsonFt) (smallJsont *self, smallArrayt *array); 1057 typedef smallJsont* (*appendNSmashSmallJsonFt) (smallJsont *self, smallArrayt *array); 1058 // not used, included in mergeSmallJson - typedef smallJsont* (*appendSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *array); 1059 // not used, included in mergeSmallJson - typedef smallJsont* (*appendSmallJsonNSmashSmallJsonFt)(smallJsont *self, smallJsont *array); 1060 typedef smallJsont* (*appendArraySmallJsonFt) (smallJsont *self, char **array); 1061 typedef smallJsont* (*appendCArraySmallJsonFt) (smallJsont *self, const char **array); 1062 typedef smallJsont* (*appendNSmashArraySmallJsonFt)(smallJsont *self, char **array); 1063 1064 /** 1065 * prepend array at the start of self by copying the pointers 1066 * from array to self. 1067 * After this function, free array with dispose/smash instead of free/terminate 1068 * 1069 * \param 1070 * array 1071 * \return 1072 * self and array in self 1073 * self not modified when self and array are NULL 1074 * or when self is identical to array (same pointers) 1075 * 0 success 1076 * -1 error 1077 */ 1078 typedef smallJsont* (*shiftSmallJsonFt) (smallJsont *self, smallArrayt *array); 1079 typedef smallJsont* (*shiftNSmashSmallJsonFt) (smallJsont *self, smallArrayt *array); 1080 typedef smallJsont* (*shiftSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *array); 1081 typedef smallJsont* (*shiftNSmashSmallJsonSmallJsonFt)(smallJsont *self, smallJsont *array); 1082 1083 /** 1084 * add self and list in a new list 1085 * 1086 * \param 1087 * list 1088 * \return 1089 * new list with self and list 1090 * empty list when self and list are NULL or empty 1091 */ 1092 typedef smallJsont* (*addSmallJsonFt) (smallJsont *self, smallArrayt *array); 1093 typedef smallJsont* (*addJsonSmallJsonFt) (smallJsont *self, smallJsont *array); 1094 1095 /** 1096 * keep elements from start and end in json, free the other elements 1097 * negative indexes are allowed 1098 * 1099 * \param 1100 * start index, must be in the array 1101 * \param 1102 * end index, must be in the array 1103 * \return 1104 * sliced array 1105 * empty array when start=end 1106 * unchanged when array is empty 1107 * unchanged when array is NULL or when start and end are not set correctly 1108 * 0 success 1109 * -1 error 1110 */ 1111 typedef smallJsont* (*sliceSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 1112 1113 /** 1114 * Crop elements from start to end 1115 * return a new list with elements from start and end in list 1116 * and delete elements from start to end in the original list 1117 * negative indexes are allowed 1118 * 1119 * Crop is faster than Slice+Del because only the 1120 * pointers are copied to the sliced list 1121 * 1122 * \param 1123 * start index, must be in the list 1124 * \param 1125 * end index, must be in the list 1126 * \return 1127 * new sliced list (you must free (terimate) the pointer) 1128 * empty list when start=end 1129 * unchanged when list is empty 1130 * unchanged when list is NULL or when start and end are not set correctly 1131 * NULL error 1132 */ 1133 typedef smallJsont* (*cropSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 1134 typedef char* (*cropSSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 1135 typedef smallStringt* (*cropSmallStringSmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 1136 1137 1138 /** 1139 * Crop a single Element 1140 * return element at index 1141 * and delete element at index in the original list 1142 * negative indexes are allowed 1143 * 1144 * \param 1145 * index must be in the list 1146 * \return 1147 * element at index (you must free the pointer (terminate libsheepy objects)) 1148 * unchanged when list is empty 1149 * NULL error 1150 */ 1151 typedef baset* (*cropElemAtSmallJsonFt) (smallJsont *self, int64_t index); 1152 typedef undefinedt* (*cropElemAtUndefinedSmallJsonFt) (smallJsont *self, int64_t index); 1153 typedef bool (*cropElemAtBoolSmallJsonFt) (smallJsont *self, int64_t index); 1154 typedef double (*cropElemAtDoubleSmallJsonFt) (smallJsont *self, int64_t index); 1155 typedef int64_t (*cropElemAtIntSmallJsonFt) (smallJsont *self, int64_t index); 1156 typedef int32_t (*cropElemAtInt32SmallJsonFt) (smallJsont *self, int64_t index); 1157 typedef uint64_t (*cropElemAtUintSmallJsonFt) (smallJsont *self, int64_t index); 1158 typedef uint32_t (*cropElemAtUint32SmallJsonFt) (smallJsont *self, int64_t index); 1159 typedef char* (*cropElemAtSSmallJsonFt) (smallJsont *self, int64_t index); 1160 typedef char (*cropElemAtCharSmallJsonFt) (smallJsont *self, int64_t index); 1161 typedef smallDictt* (*cropElemAtDictSmallJsonFt) (smallJsont *self, int64_t index); 1162 typedef smallArrayt* (*cropElemAtArraySmallJsonFt) (smallJsont *self, int64_t index); 1163 typedef smallBoolt* (*cropElemAtSmallBoolSmallJsonFt) (smallJsont *self, int64_t index); 1164 typedef smallBytest* (*cropElemAtSmallBytesSmallJsonFt) (smallJsont *self, int64_t index); 1165 typedef smallDoublet* (*cropElemAtSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index); 1166 typedef smallIntt* (*cropElemAtSmallIntSmallJsonFt) (smallJsont *self, int64_t index); 1167 typedef smallJsont* (*cropElemAtSmallJsonSmallJsonFt) (smallJsont *self, int64_t index); 1168 typedef smallStringt* (*cropElemAtSmallStringSmallJsonFt) (smallJsont *self, int64_t index); 1169 typedef void* (*cropElemAtVoidSmallJsonFt) (smallJsont *self, int64_t index); 1170 typedef smallContainert* (*cropElemAtSmallContainerSmallJsonFt) (smallJsont *self, int64_t index); 1171 1172 /** 1173 * Crop an Element 1174 * return element for key 1175 * and delete element in dictionary 1176 * negative indexes are allowed 1177 * 1178 * \param 1179 * key must exist in the dictionary 1180 * \return 1181 * element for key (you must free the pointer (terminate libsheepy objects)) 1182 * NULL error 1183 */ 1184 typedef baset* (*cropElemKeySmallJsonFt) (smallJsont *self, const char* key); 1185 typedef undefinedt* (*cropElemKeyUndefinedSmallJsonFt) (smallJsont *self, const char* key); 1186 typedef bool (*cropElemKeyBoolSmallJsonFt) (smallJsont *self, const char* key); 1187 typedef double (*cropElemKeyDoubleSmallJsonFt) (smallJsont *self, const char* key); 1188 typedef int64_t (*cropElemKeyIntSmallJsonFt) (smallJsont *self, const char* key); 1189 typedef int32_t (*cropElemKeyInt32SmallJsonFt) (smallJsont *self, const char* key); 1190 typedef uint64_t (*cropElemKeyUintSmallJsonFt) (smallJsont *self, const char* key); 1191 typedef uint32_t (*cropElemKeyUint32SmallJsonFt) (smallJsont *self, const char* key); 1192 typedef char* (*cropElemKeySSmallJsonFt) (smallJsont *self, const char* key); 1193 typedef smallDictt* (*cropElemKeyDictSmallJsonFt) (smallJsont *self, const char* key); 1194 typedef smallArrayt* (*cropElemKeyArraySmallJsonFt) (smallJsont *self, const char* key); 1195 typedef smallBoolt* (*cropElemKeySmallBoolSmallJsonFt) (smallJsont *self, const char* key); 1196 typedef smallBytest* (*cropElemKeySmallBytesSmallJsonFt) (smallJsont *self, const char* key); 1197 typedef smallDoublet* (*cropElemKeySmallDoubleSmallJsonFt) (smallJsont *self, const char* key); 1198 typedef smallIntt* (*cropElemKeySmallIntSmallJsonFt) (smallJsont *self, const char* key); 1199 typedef smallJsont* (*cropElemKeySmallJsonSmallJsonFt) (smallJsont *self, const char* key); 1200 typedef smallStringt* (*cropElemKeySmallStringSmallJsonFt) (smallJsont *self, const char* key); 1201 typedef void* (*cropElemKeyVoidSmallJsonFt) (smallJsont *self, const char* key); 1202 typedef smallContainert* (*cropElemKeySmallContainerSmallJsonFt) (smallJsont *self, const char* key); 1203 1204 /** 1205 * keep elements from start and end in list, free the other elements 1206 * negative indexes are allowed 1207 * 1208 * \param 1209 * start index, must be in the list 1210 * \param 1211 * end index, must be in the list 1212 * \return 1213 * new sliced list 1214 * empty list when start=end 1215 * unchanged when list is empty 1216 * unchanged when list is NULL or when start and end are not set correctly 1217 * NULL error 1218 */ 1219 typedef smallJsont* (*copySmallJsonFt) (smallJsont *self, int64_t start, int64_t end); 1220 1221 /** 1222 * insert array in self at index 1223 * After this function, free toInsert with dispose/smash instead of free/terminate 1224 * 1225 * return array with toInsert at index 1226 * negative indexes are allowed 1227 * 1228 * \param 1229 * index in array 1230 * \param 1231 * toInsert array 1232 * \return 1233 * array 1234 * unchanged array when array is NULL or invalid index 1235 * NULL error 1236 */ 1237 typedef smallJsont* (*insertSmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *toInsert); 1238 typedef smallJsont* (*insertNSmashSmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *toInsert); 1239 typedef smallJsont* (*insertSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *toInsert); 1240 typedef smallJsont* (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *self, int64_t index, smallJsont *toInsert); 1241 1242 /** 1243 * insert smallString in self at index 1244 * 1245 * return smallString with toInsert at index 1246 * negative indexes are allowed 1247 * index -1 is the end of the array and is equivalent to index len 1248 * 1249 * \param 1250 * index in smallString 1251 * \param 1252 * toInsert smallString 1253 * \return 1254 * self smallString 1255 * NULL unchanged smallString when smallString is NULL or invalid index 1256 */ 1257 typedef smallJsont* (*insertStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *toInsert); 1258 typedef smallJsont* (*insertSSmallJsonFt) (smallJsont *self, int64_t index, const char *toInsert); 1259 typedef smallJsont* (*insertNFreeStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *toInsert); 1260 typedef smallJsont* (*insertSNFreeSmallJsonFt) (smallJsont *self, int64_t index, char *toInsert); 1261 1262 /** 1263 * inject an element in self at index 1264 * 1265 * return array with toInject at index 1266 * negative indexes are allowed 1267 * 1268 * \param 1269 * index in array 1270 * \param 1271 * toInject element 1272 * \return 1273 * array 1274 * unchanged array when array is NULL or invalid index 1275 * NULL error 1276 */ 1277 typedef smallJsont* (*injectSmallJsonFt) (smallJsont *self, int64_t index, baset *toInject); 1278 typedef smallJsont* (*injectUndefinedSmallJsonFt)(smallJsont *self, int64_t index); 1279 typedef smallJsont* (*injectBoolSmallJsonFt) (smallJsont *self, int64_t index, bool toInject); 1280 typedef smallJsont* (*injectDoubleSmallJsonFt) (smallJsont *self, int64_t index, double toInject); 1281 typedef smallJsont* (*injectIntSmallJsonFt) (smallJsont *self, int64_t index, int64_t toInject); 1282 typedef smallJsont* (*injectSSmallJsonFt) (smallJsont *self, int64_t index, const char *toInject); 1283 typedef smallJsont* (*injectCharSmallJsonFt) (smallJsont *self, int64_t index, char c); 1284 typedef smallJsont* (*injectDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *toInject); 1285 typedef smallJsont* (*injectArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *toInject); 1286 typedef smallJsont* (*injectArraycSmallJsonFt) (smallJsont *self, int64_t index, char **toInject); 1287 typedef smallJsont* (*injectCArraycSmallJsonFt) (smallJsont *self, int64_t index, const char **toInject); 1288 typedef smallJsont* (*injectSmallBoolSmallJsonFt) (smallJsont *self, int64_t index, smallBoolt *toInject); 1289 typedef smallJsont* (*injectSmallBytesSmallJsonFt) (smallJsont *self, int64_t index, smallBytest *toInject); 1290 typedef smallJsont* (*injectSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index, smallDoublet *toInject); 1291 typedef smallJsont* (*injectSmallIntSmallJsonFt) (smallJsont *self, int64_t index, smallIntt *toInject); 1292 typedef smallJsont* (*injectSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *toInject); 1293 typedef smallJsont* (*injectSmallStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *toInject); 1294 typedef smallJsont* (*injectSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject); 1295 1296 typedef smallJsont* (*injectNFreeSmallJsonFt) (smallJsont *self, int64_t index, baset *toInject); 1297 typedef smallJsont* (*injectNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined); 1298 typedef smallJsont* (*injectNFreeSSmallJsonFt) (smallJsont *self, int64_t index, char *toInject); 1299 typedef smallJsont* (*injectNFreeDictSmallJsonFt) (smallJsont *self, int64_t index, smallDictt *toInject); 1300 typedef smallJsont* (*injectNFreeArraySmallJsonFt) (smallJsont *self, int64_t index, smallArrayt *toInject); 1301 typedef smallJsont* (*injectNFreeArraycSmallJsonFt) (smallJsont *self, int64_t index, char **toInject); 1302 typedef smallJsont* (*injectNFreeSmallBoolSmallJsonFt) (smallJsont *self, int64_t index, smallBoolt *toInject); 1303 typedef smallJsont* (*injectNFreeSmallBytesSmallJsonFt) (smallJsont *self, int64_t index, smallBytest *toInject); 1304 typedef smallJsont* (*injectNFreeSmallDoubleSmallJsonFt) (smallJsont *self, int64_t index, smallDoublet *toInject); 1305 typedef smallJsont* (*injectNFreeSmallIntSmallJsonFt) (smallJsont *self, int64_t index, smallIntt *toInject); 1306 typedef smallJsont* (*injectNFreeSmallJsonSmallJsonFt) (smallJsont *self, int64_t index, smallJsont *toInject); 1307 typedef smallJsont* (*injectNFreeSmallStringSmallJsonFt) (smallJsont *self, int64_t index, smallStringt *toInject); 1308 typedef smallJsont* (*injectNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject); 1309 1310 /** 1311 * Uniquify elements of list 1312 * each elements are unique in self 1313 * 1314 * \return 1315 * self with unique elements 1316 * empty list when list is empty 1317 * 0 success 1318 * -1 error 1319 */ 1320 typedef smallJsont* (*uniqSmallJsonFt) (smallJsont *self); 1321 1322 /** 1323 * ignore case and uniquify elements of list 1324 * each elements are unique in self 1325 * 1326 * \return 1327 * self with unique elements 1328 * empty list when list is empty 1329 * 0 success 1330 * -1 error 1331 */ 1332 typedef smallJsont* (*icUniqSmallJsonFt) (smallJsont *self); 1333 1334 /** 1335 * uniq String 1336 * 1337 * remove successive repetitions of char c 1338 * 1339 * \param 1340 * string 1341 * c character to remove 1342 * \return 1343 * string without successive repetitions of char c 1344 * 0 ok 1345 * -1 error 1346 */ 1347 typedef smallJsont* (*uniqCharSmallJsonFt) (smallJsont *self, char c); 1348 1349 /** 1350 * ignore case uniq String 1351 * 1352 * remove successive repetitions of char c 1353 * 1354 * \param 1355 * string 1356 * c character to remove 1357 * \return 1358 * string without successive repetitions of char c 1359 * 0 ok 1360 * -1 error 1361 */ 1362 typedef smallJsont* (*icUniqCharSmallJsonFt) (smallJsont *self, char c); 1363 1364 /** 1365 * sort self in alphabetic order 1366 * 1367 * \return 1368 * sorted list 1369 * empty list when list is empty 1370 * unchanged list when list is NULL 1371 * 0 success 1372 * -1 error 1373 */ 1374 typedef smallJsont* (*sortSmallJsonFt) (smallJsont *self); 1375 1376 1377 /** 1378 * sort self according to the results from the compareFunction function 1379 * 1380 * shCmpt is defined in libsheepy.h 1381 * typedef int (*shCmp)(const void * a, const void * b); 1382 * 1383 * a and b are baset objects, cast to the correct class by using the object type 1384 * 1385 * cast macros: castS(s, S) and cast(smallJsont*, a, A) 1386 * 1387 * \return 1388 * sorted list 1389 * NULL error 1390 */ 1391 typedef smallJsont* (*sortFSmallJsonFt) (smallJsont *self, shCmpt compareFunction); 1392 1393 /** 1394 * ignore case sort self in alphabetic order 1395 * 1396 * \return 1397 * sorted list 1398 * empty list when list is empty 1399 * unchanged list when list is NULL 1400 * 0 success 1401 * -1 error 1402 */ 1403 typedef smallJsont* (*icSortSmallJsonFt) (smallJsont *self); 1404 1405 /** 1406 * check if self has object 1407 * 1408 * \param 1409 * object to find 1410 * \return 1411 * true when the object is found 1412 */ 1413 typedef bool (*hasSmallJsonFt) (smallJsont *self, baset *value); 1414 typedef bool (*hasUndefinedSmallJsonFt)(smallJsont *self, undefinedt *undefined); 1415 typedef bool (*hasBoolSmallJsonFt) (smallJsont *self, bool value); 1416 typedef bool (*hasDoubleSmallJsonFt) (smallJsont *self, double value); 1417 typedef bool (*hasIntSmallJsonFt) (smallJsont *self, int64_t value); 1418 typedef bool (*hasSSmallJsonFt) (smallJsont *self, const char *string); 1419 typedef bool (*hasCharSmallJsonFt) (smallJsont *self, char c); 1420 typedef bool (*hasDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1421 typedef bool (*hasArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1422 typedef bool (*hasArraycSmallJsonFt) (smallJsont *self, char **array); 1423 typedef bool (*hasCArraycSmallJsonFt) (smallJsont *self, const char **array); 1424 typedef bool (*hasSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 1425 typedef bool (*hasSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 1426 typedef bool (*hasSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 1427 typedef bool (*hasSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 1428 typedef bool (*hasSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 1429 typedef bool (*hasSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1430 typedef bool (*hasSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 1431 1432 /** 1433 * find SmallString 1434 * 1435 * \param 1436 * needle: smallString to find 1437 * \return 1438 * new smallJsont smallString of first occurence of needle in smallString 1439 * NULL when needle is not found 1440 * NULL when smallString or needle are NULL 1441 */ 1442 typedef smallJsont* (*findSmallJsonFt) (smallJsont *self, const char *needle); 1443 typedef smallJsont* (*findCharSmallJsonFt) (smallJsont *self, char c); 1444 typedef smallJsont* (*findSmallStringSmallJsonFt)(smallJsont *self, smallStringt *needle); 1445 typedef smallJsont* (*findJsonSmallJsonFt) (smallJsont *self, smallJsont *needle); 1446 1447 /** 1448 * return index of object in list 1449 * 1450 * \param 1451 * value 1452 * \return 1453 * index 1454 * -1 when the value is not found 1455 * -1 when array or value are NULL 1456 */ 1457 typedef ssize_t (*indexOfSmallJsonFt) (smallJsont *self, baset *value); 1458 typedef ssize_t (*indexOfUndefinedSmallJsonFt)(smallJsont *self, undefinedt *undefined); 1459 typedef ssize_t (*indexOfBoolSmallJsonFt) (smallJsont *self, bool value); 1460 typedef ssize_t (*indexOfDoubleSmallJsonFt) (smallJsont *self, double value); 1461 typedef ssize_t (*indexOfIntSmallJsonFt) (smallJsont *self, int64_t value); 1462 typedef ssize_t (*indexOfSSmallJsonFt) (smallJsont *self, const char *string); 1463 typedef ssize_t (*indexOfCharSmallJsonFt) (smallJsont *self, char c); 1464 typedef ssize_t (*indexOfDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1465 typedef ssize_t (*indexOfArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1466 typedef ssize_t (*indexOfArraycSmallJsonFt) (smallJsont *self, char **array); 1467 typedef ssize_t (*indexOfCArraycSmallJsonFt) (smallJsont *self, const char **array); 1468 typedef ssize_t (*indexOfSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 1469 typedef ssize_t (*indexOfSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 1470 typedef ssize_t (*indexOfSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 1471 typedef ssize_t (*indexOfSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 1472 typedef ssize_t (*indexOfSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 1473 typedef ssize_t (*indexOfSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1474 typedef ssize_t (*indexOfSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 1475 1476 /** 1477 * efficiently finds the index of object in list 1478 * the list has be sorted with the sort function 1479 * 1480 * \param 1481 * value to search 1482 * \return 1483 * index of value 1484 * -1 value not found or NULL input pointers 1485 */ 1486 typedef ssize_t (*binarySearchSmallJsonFt) (smallJsont *self, baset *value); 1487 typedef ssize_t (*binarySearchUndefinedSmallJsonFt)(smallJsont *self, undefinedt *undefined); 1488 typedef ssize_t (*binarySearchBoolSmallJsonFt) (smallJsont *self, bool value); 1489 typedef ssize_t (*binarySearchDoubleSmallJsonFt) (smallJsont *self, double value); 1490 typedef ssize_t (*binarySearchIntSmallJsonFt) (smallJsont *self, int64_t value); 1491 typedef ssize_t (*binarySearchSSmallJsonFt) (smallJsont *self, const char *string); 1492 typedef ssize_t (*binarySearchCharSmallJsonFt) (smallJsont *self, char c); 1493 typedef ssize_t (*binarySearchDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1494 typedef ssize_t (*binarySearchArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1495 typedef ssize_t (*binarySearchArraycSmallJsonFt) (smallJsont *self, char **array); 1496 typedef ssize_t (*binarySearchCArraycSmallJsonFt) (smallJsont *self, const char **array); 1497 typedef ssize_t (*binarySearchSmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 1498 typedef ssize_t (*binarySearchSmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 1499 typedef ssize_t (*binarySearchSmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 1500 typedef ssize_t (*binarySearchSmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 1501 typedef ssize_t (*binarySearchSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 1502 typedef ssize_t (*binarySearchSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1503 typedef ssize_t (*binarySearchSmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 1504 1505 /** 1506 * ignore case and check if self has object 1507 * 1508 * \param 1509 * object to find 1510 * \return 1511 * true when the object is found 1512 */ 1513 typedef bool (*icHasSmallJsonFt) (smallJsont *self, baset *value); 1514 typedef bool (*icHasSSmallJsonFt) (smallJsont *self, const char *string); 1515 typedef bool (*icHasCharSmallJsonFt) (smallJsont *self, char c); 1516 typedef bool (*icHasDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1517 typedef bool (*icHasArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1518 typedef bool (*icHasArraycSmallJsonFt) (smallJsont *self, char **array); 1519 typedef bool (*icHasCArraycSmallJsonFt) (smallJsont *self, const char **array); 1520 typedef bool (*icHasSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1521 1522 /** 1523 * ignore case find SmallString 1524 * 1525 * \param 1526 * needle: smallString to find 1527 * \return 1528 * new smallJsont smallString of first occurence of needle in smallString 1529 * NULL when needle is not found 1530 * NULL when smallString or needle are NULL 1531 */ 1532 typedef smallJsont* (*icFindSmallJsonFt) (smallJsont *self, const char *needle); 1533 typedef smallJsont* (*icFindCharSmallJsonFt) (smallJsont *self, char c); 1534 typedef smallJsont* (*icFindSmallStringSmallJsonFt)(smallJsont *self, smallStringt *needle); 1535 typedef smallJsont* (*icFindJsonSmallJsonFt) (smallJsont *self, smallJsont *needle); 1536 1537 /** 1538 * ignore case and return index of object in list 1539 * 1540 * \param 1541 * value 1542 * \return 1543 * index 1544 * -1 when the value is not found 1545 * -1 when array or value are NULL 1546 */ 1547 typedef ssize_t (*icIndexOfSmallJsonFt) (smallJsont *self, baset *value); 1548 typedef ssize_t (*icIndexOfSSmallJsonFt) (smallJsont *self, const char *string); 1549 typedef ssize_t (*icIndexOfCharSmallJsonFt) (smallJsont *self, char c); 1550 typedef ssize_t (*icIndexOfDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1551 typedef ssize_t (*icIndexOfArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1552 typedef ssize_t (*icIndexOfArraycSmallJsonFt) (smallJsont *self, char **array); 1553 typedef ssize_t (*icIndexOfCArraycSmallJsonFt) (smallJsont *self, const char **array); 1554 typedef ssize_t (*icIndexOfSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1555 1556 /** 1557 * ignore case and efficiently finds the index of object in list 1558 * the list has be sorted with the sort function 1559 * 1560 * \param 1561 * value to search 1562 * \return 1563 * index of value 1564 * -1 value not found or NULL input pointers 1565 */ 1566 typedef ssize_t (*icBinarySearchSmallJsonFt) (smallJsont *self, baset *value); 1567 typedef ssize_t (*icBinarySearchSSmallJsonFt) (smallJsont *self, const char *string); 1568 typedef ssize_t (*icBinarySearchCharSmallJsonFt) (smallJsont *self, char c); 1569 typedef ssize_t (*icBinarySearchDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1570 typedef ssize_t (*icBinarySearchArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1571 typedef ssize_t (*icBinarySearchArraycSmallJsonFt) (smallJsont *self, char **array); 1572 typedef ssize_t (*icBinarySearchCArraycSmallJsonFt) (smallJsont *self, const char **array); 1573 typedef ssize_t (*icBinarySearchSmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1574 1575 /** 1576 * return key for object in dictionary 1577 * 1578 * \param 1579 * value 1580 * \return 1581 * key 1582 * NULL when the value is not found 1583 * NULL when array or value are NULL 1584 */ 1585 typedef char* (*keyBySmallJsonFt) (smallJsont *self, baset *value); 1586 typedef char* (*keyByUndefinedSmallJsonFt)(smallJsont *self, undefinedt *undefined); 1587 typedef char* (*keyByBoolSmallJsonFt) (smallJsont *self, bool value); 1588 typedef char* (*keyByDoubleSmallJsonFt) (smallJsont *self, double value); 1589 typedef char* (*keyByIntSmallJsonFt) (smallJsont *self, int64_t value); 1590 typedef char* (*keyBySSmallJsonFt) (smallJsont *self, const char *string); 1591 typedef char* (*keyByCharSmallJsonFt) (smallJsont *self, char c); 1592 typedef char* (*keyByDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1593 typedef char* (*keyByArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1594 typedef char* (*keyByArraycSmallJsonFt) (smallJsont *self, char **array); 1595 typedef char* (*keyByCArraycSmallJsonFt) (smallJsont *self, const char **array); 1596 typedef char* (*keyBySmallBoolSmallJsonFt) (smallJsont *self, smallBoolt *value); 1597 typedef char* (*keyBySmallBytesSmallJsonFt) (smallJsont *self, smallBytest *value); 1598 typedef char* (*keyBySmallDoubleSmallJsonFt) (smallJsont *self, smallDoublet *value); 1599 typedef char* (*keyBySmallIntSmallJsonFt) (smallJsont *self, smallIntt *value); 1600 typedef char* (*keyBySmallJsonSmallJsonFt) (smallJsont *self, smallJsont *value); 1601 typedef char* (*keyBySmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1602 typedef char* (*keyBySmallContainerSmallJsonFt)(smallJsont *self, smallContainert *container); 1603 1604 /** 1605 * ignore case and return key for object in dictionary 1606 * 1607 * \param 1608 * value 1609 * \return 1610 * key 1611 * NULL when the value is not found 1612 * NULL when array or value are NULL 1613 */ 1614 typedef char* (*icKeyBySmallJsonFt) (smallJsont *self, baset *value); 1615 typedef char* (*icKeyBySSmallJsonFt) (smallJsont *self, const char *string); 1616 typedef char* (*icKeyByCharSmallJsonFt) (smallJsont *self, char c); 1617 typedef char* (*icKeyByDictSmallJsonFt) (smallJsont *self, smallDictt *dict); 1618 typedef char* (*icKeyByArraySmallJsonFt) (smallJsont *self, smallArrayt *array); 1619 typedef char* (*icKeyByArraycSmallJsonFt) (smallJsont *self, char **array); 1620 typedef char* (*icKeyByCArraycSmallJsonFt) (smallJsont *self, const char **array); 1621 typedef char* (*icKeyBySmallStringSmallJsonFt) (smallJsont *self, smallStringt *string); 1622 1623 /** 1624 * replace 1625 * the olds smallString is replaced with the news smallString max times in the result 1626 * 0 for max means replace all olds smallStrings 1627 * 1628 * \param 1629 * olds: old smallString to be replaced in self 1630 * \param 1631 * news: new smallString replacing olds in self 1632 * \param 1633 * max: number of times to replace olds, 0 to replace all found olds 1634 * \return 1635 * 0 modified self 1636 * -1 s not modified when self buffer is NULL or empty and when olds is empty 1637 */ 1638 typedef smallJsont* (*replaceSmallJsonFt) (smallJsont *self, const char *olds, const char *news, size_t max); 1639 //#define replaceSO_max(obj,olds,news) (obj)->f->replace(obj,olds,news, 0) 1640 typedef smallJsont* (*replaceCharSSmallJsonFt) (smallJsont *self, char olds, const char *news, size_t max); 1641 typedef smallJsont* (*replaceSCharSmallJsonFt) (smallJsont *self, const char *olds, char news, size_t max); 1642 typedef smallJsont* (*replaceCharCharSmallJsonFt)(smallJsont *self, char olds, char news, size_t max); 1643 typedef smallJsont* (*replaceSmallStringSmallStringSmallJsonFt)(smallJsont *self, smallStringt *olds, smallStringt *news, size_t max); 1644 typedef smallJsont* (*replaceSmallStringSSmallJsonFt) (smallJsont *self, smallStringt *olds, const char *news, size_t max); 1645 typedef smallJsont* (*replaceSmallStringCharSmallJsonFt) (smallJsont *self, smallStringt *olds, char news, size_t max); 1646 typedef smallJsont* (*replaceSSmallStringSmallJsonFt) (smallJsont *self, const char *olds, smallStringt *news, size_t max); 1647 typedef smallJsont* (*replaceCharSmallStringSmallJsonFt) (smallJsont *self, char olds, smallStringt *news, size_t max); 1648 typedef smallJsont* (*replaceJsonJsonSmallJsonFt) (smallJsont *self, smallJsont *olds, smallJsont *news, size_t max); 1649 typedef smallJsont* (*replaceJsonSmallStringSmallJsonFt) (smallJsont *self, smallJsont *olds, smallStringt *news, size_t max); 1650 typedef smallJsont* (*replaceJsonSSmallJsonFt) (smallJsont *self, smallJsont *olds, const char *news, size_t max); 1651 typedef smallJsont* (*replaceJsonCharSmallJsonFt) (smallJsont *self, smallJsont *olds, char news, size_t max); 1652 typedef smallJsont* (*replaceSmallStringJsonSmallJsonFt) (smallJsont *self, smallStringt *olds, smallJsont *news, size_t max); 1653 typedef smallJsont* (*replaceSJsonSmallJsonFt) (smallJsont *self, const char *olds, smallJsont *news, size_t max); 1654 typedef smallJsont* (*replaceCharJsonSmallJsonFt) (smallJsont *self, char olds, smallJsont *news, size_t max); 1655 1656 /** 1657 * replace Many Strings 1658 * the olds string is replaced with the news string max times in the result 1659 * 1660 * Example: 1661 * replaceMany(self, "s", "BNM", "a", "AAA") 1662 * ^olds ^news ^olds ^news 1663 * 1664 * \param 1665 * self 1666 * olds: old string to be replaced in s 1667 * news: new string replacing olds in s 1668 * ... 1669 * \return 1670 * 0 modified string 1671 * -1 not modified when s is empty, when s is NULL, when only 2 parameters are given, 1672 * when any olds is empty 1673 */ 1674 typedef smallJsont* (*replaceManySmallJsonFt)(smallJsont *self, const char *paramType, ...); 1675 //#define replaceManyO(self, olds, ...) (self)->f->replaceMany(self, olds, __VA_ARGS__, NULL) 1676 //#define replaceManyG replaceManyO 1677 1678 /** 1679 * ignore case replace 1680 * the olds smallString is replaced with the news smallString max times in the result 1681 * 0 for max means replace all olds smallStrings 1682 * 1683 * \param 1684 * olds: old smallString to be replaced in self 1685 * \param 1686 * news: new smallString replacing olds in self 1687 * \param 1688 * max: number of times to replace olds, 0 to replace all found olds 1689 * \return 1690 * 0 modified self 1691 * -1 s not modified when self buffer is NULL or empty and when olds is empty 1692 */ 1693 typedef smallJsont* (*icReplaceSmallJsonFt) (smallJsont *self, const char *olds, const char *news, size_t max); 1694 //#define icReplaceSO_max(obj,olds,news) (obj)->f->replace(obj,olds,news, 0) 1695 typedef smallJsont* (*icReplaceCharSSmallJsonFt) (smallJsont *self, char olds, const char *news, size_t max); 1696 typedef smallJsont* (*icReplaceSCharSmallJsonFt) (smallJsont *self, const char *olds, char news, size_t max); 1697 typedef smallJsont* (*icReplaceCharCharSmallJsonFt)(smallJsont *self, char olds, char news, size_t max); 1698 typedef smallJsont* (*icReplaceSmallStringSmallStringSmallJsonFt)(smallJsont *self, smallStringt *olds, smallStringt *news, size_t max); 1699 typedef smallJsont* (*icReplaceSmallStringSSmallJsonFt) (smallJsont *self, smallStringt *olds, const char *news, size_t max); 1700 typedef smallJsont* (*icReplaceSmallStringCharSmallJsonFt) (smallJsont *self, smallStringt *olds, char news, size_t max); 1701 typedef smallJsont* (*icReplaceSSmallStringSmallJsonFt) (smallJsont *self, const char *olds, smallStringt *news, size_t max); 1702 typedef smallJsont* (*icReplaceCharSmallStringSmallJsonFt) (smallJsont *self, char olds, smallStringt *news, size_t max); 1703 typedef smallJsont* (*icReplaceJsonJsonSmallJsonFt) (smallJsont *self, smallJsont *olds, smallJsont *news, size_t max); 1704 typedef smallJsont* (*icReplaceJsonSmallStringSmallJsonFt) (smallJsont *self, smallJsont *olds, smallStringt *news, size_t max); 1705 typedef smallJsont* (*icReplaceJsonSSmallJsonFt) (smallJsont *self, smallJsont *olds, const char *news, size_t max); 1706 typedef smallJsont* (*icReplaceJsonCharSmallJsonFt) (smallJsont *self, smallJsont *olds, char news, size_t max); 1707 typedef smallJsont* (*icReplaceSmallStringJsonSmallJsonFt) (smallJsont *self, smallStringt *olds, smallJsont *news, size_t max); 1708 typedef smallJsont* (*icReplaceSJsonSmallJsonFt) (smallJsont *self, const char *olds, smallJsont *news, size_t max); 1709 typedef smallJsont* (*icReplaceCharJsonSmallJsonFt) (smallJsont *self, char olds, smallJsont *news, size_t max); 1710 1711 /** 1712 * ignore case replace Many Strings 1713 * the olds string is replaced with the news string max times in the result 1714 * 1715 * Example: 1716 * replaceMany(self, "s", "BNM", "a", "AAA") 1717 * ^olds ^news ^olds ^news 1718 * 1719 * \param 1720 * self 1721 * olds: old string to be replaced in s 1722 * news: new string replacing olds in s 1723 * ... 1724 * \return 1725 * 0 modified string 1726 * -1 not modified when s is empty, when s is NULL, when only 2 parameters are given, 1727 * when any olds is empty 1728 */ 1729 typedef smallJsont* (*icReplaceManySmallJsonFt)(smallJsont *self, const char *paramType, ...); 1730 //#define icReplaceManyO(self, olds, ...) (self)->f->icReplaceMany(self, olds, __VA_ARGS__, NULL) 1731 //#define icReplaceManyG icReplaceManyO 1732 1733 /** 1734 * compare each element of self and list 1735 * 1736 * \param 1737 * list 1738 * \return 1739 * true the lists have identical elements 1740 * false they differ 1741 */ 1742 typedef bool (*equalSmallJsonSmallArrayFt) (smallJsont *self, smallArrayt *array); 1743 typedef bool (*equalSmallJsonArrayFt) (smallJsont *self, char ** p2); 1744 typedef bool (*equalSmallJsonCArrayFt) (smallJsont *self, const char ** p2); 1745 typedef bool (*equalSmallJsonBaseFt) (smallJsont *self, baset* p2); 1746 typedef bool (*equalSmallJsonChaFt) (smallJsont* self, char p2); 1747 typedef bool (*equalSmallJsonCharFt) (smallJsont* self, const char * p2); 1748 typedef bool (*equalSmallJsonBoolFt) (smallJsont* self, bool p2); 1749 typedef bool (*equalSmallJsonDoubleFt) (smallJsont* self, double p2); 1750 typedef bool (*equalSmallJsonInt64Ft) (smallJsont* self, int64_t p2); 1751 typedef bool (*equalSmallJsonInt32Ft) (smallJsont* self, int32_t p2); 1752 typedef bool (*equalSmallJsonUint32Ft) (smallJsont* self, uint32_t p2); 1753 typedef bool (*equalSmallJsonUint64Ft) (smallJsont* self, uint64_t p2); 1754 typedef bool (*equalSmallJsonSmallBoolFt) (smallJsont* self, smallBoolt* p2); 1755 typedef bool (*equalSmallJsonSmallBytesFt) (smallJsont* self, smallBytest* p2); 1756 typedef bool (*equalSmallJsonSmallDoubleFt) (smallJsont* self, smallDoublet* p2); 1757 typedef bool (*equalSmallJsonSmallIntFt) (smallJsont* self, smallIntt* p2); 1758 typedef bool (*equalSmallJsonSmallJsonFt) (smallJsont* self, smallJsont* p2); 1759 typedef bool (*equalSmallJsonSmallStringFt) (smallJsont* self, smallStringt* p2); 1760 typedef bool (*equalSmallJsonSmallDictFt) (smallJsont* self, smallDictt* p2); 1761 1762 /** 1763 * ignore case and compare each element of self and list 1764 * 1765 * \param 1766 * list 1767 * \return 1768 * true the lists have identical elements 1769 * false they differ 1770 */ 1771 typedef bool (*icEqualSmallJsonSmallArrayFt) (smallJsont *self, smallArrayt *array); 1772 typedef bool (*icEqualSmallJsonArrayFt) (smallJsont *self, char ** p2); 1773 typedef bool (*icEqualSmallJsonCArrayFt) (smallJsont *self, const char ** p2); 1774 typedef bool (*icEqualSmallJsonBaseFt) (smallJsont *self, baset* p2); 1775 typedef bool (*icEqualSmallJsonSmallDictFt) (smallJsont* self, smallDictt* p2); 1776 typedef bool (*icEqualSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1777 typedef bool (*icEqualSmallJsonSmallStringFt)(smallJsont *self, smallStringt *string); 1778 typedef bool (*icEqualSSmallJsonFt) (smallJsont *self, const char *string); 1779 typedef bool (*icEqualCharSmallJsonFt) (smallJsont *self, char c); 1780 1781 /** 1782 * equal at Index 1783 * compare self at index to smallString 1784 * 1785 * \param 1786 * smallString to compare 1787 * \return 1788 * true smallString at index is equal to string 1789 * false they differ 1790 */ 1791 typedef bool (*equalISSmallJsonFt) (smallJsont *self, const char *string, int64_t index); 1792 typedef bool (*equalICharSmallJsonFt)(smallJsont *self, char c, int64_t index); 1793 typedef bool (*equalIJsonSmallJsonFt)(smallJsont *self, smallJsont *string, int64_t index); 1794 typedef bool (*equalISmallStringSmallJsonFt) (smallJsont *self, smallStringt *string, int64_t index); 1795 1796 /** 1797 * starts With String 1798 * compare start of self with string 1799 * 1800 * \param 1801 * string 1802 * \return 1803 * true when self starts with string 1804 * false for other cases 1805 */ 1806 typedef bool (*startsWithSSmallJsonFt) (smallJsont *self, const char *string); 1807 typedef bool (*startsWithCharSmallJsonFt)(smallJsont *self, char c); 1808 typedef bool (*startsWithSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1809 typedef bool (*startsWithJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1810 1811 /** 1812 * ends With String 1813 * compare end of self with string 1814 * 1815 * \param 1816 * string 1817 * \return 1818 * true when self ends with string2 1819 * false for other cases 1820 */ 1821 typedef bool (*endsWithSSmallJsonFt) (smallJsont *self, const char *string); 1822 typedef bool (*endsWithCharSmallJsonFt)(smallJsont *self, char c); 1823 typedef bool (*endsWithSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1824 typedef bool (*endsWithJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1825 1826 /** 1827 * count String 1828 * count number of (non-overlapping) occurrences of a substring 1829 * 1830 * Example: 1831 * assert(countS("aaa aaa", "a") == 6); 1832 * assert(countS("aaa aaa", "ab") == 0); 1833 * assert(countS("aaa aaa", "aa") == 2); 1834 * 1835 * \param 1836 * string 1837 * \return 1838 * string count 1839 * -1 when there is an error 1840 */ 1841 typedef ssize_t (*countSSmallJsonFt) (smallJsont *self, const char *string); 1842 typedef ssize_t (*countCharSmallJsonFt) (smallJsont *self, char c); 1843 typedef ssize_t (*countSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1844 typedef ssize_t (*countJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1845 1846 /** 1847 * ignore case starts With String 1848 * compare start of self with string 1849 * 1850 * \param 1851 * string 1852 * \return 1853 * true when self starts with string 1854 * false for other cases 1855 */ 1856 typedef bool (*icStartsWithSSmallJsonFt) (smallJsont *self, const char *string); 1857 typedef bool (*icStartsWithCharSmallJsonFt)(smallJsont *self, char c); 1858 typedef bool (*icStartsWithSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1859 typedef bool (*icStartsWithJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1860 1861 /** 1862 * ignore case ends With String 1863 * compare end of self with string 1864 * 1865 * \param 1866 * string 1867 * \return 1868 * true when self ends with string2 1869 * false for other cases 1870 */ 1871 typedef bool (*icEndsWithSSmallJsonFt) (smallJsont *self, const char *string); 1872 typedef bool (*icEndsWithCharSmallJsonFt)(smallJsont *self, char c); 1873 typedef bool (*icEndsWithSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1874 typedef bool (*icEndsWithJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1875 1876 /** 1877 * ignore case count String 1878 * count number of (non-overlapping) occurrences of a substring 1879 * 1880 * Example: 1881 * assert(countS("aaa aaa", "a") == 6); 1882 * assert(countS("aaa aaa", "ab") == 0); 1883 * assert(countS("aaa aaa", "aa") == 2); 1884 * 1885 * \param 1886 * string 1887 * \return 1888 * string count 1889 * -1 when there is an error 1890 */ 1891 typedef ssize_t (*icCountSSmallJsonFt) (smallJsont *self, const char *string); 1892 typedef ssize_t (*icCountCharSmallJsonFt) (smallJsont *self, char c); 1893 typedef ssize_t (*icCountSmallStringSmallJsonFt)(smallJsont *self, smallStringt *string); 1894 typedef ssize_t (*icCountJsonSmallJsonFt) (smallJsont *self, smallJsont *string); 1895 1896 /** 1897 * is Number (integer or float) String 1898 * 1899 * 1, -12 1900 * 1e+4, .44E-1 1901 * 1902 * \param 1903 * string 1904 * \return 1905 * true when string is a number 1906 * false when string is not a number or string is empty or NULL 1907 */ 1908 typedef bool (*isNumberSmallJsonFt) (smallJsont *self); 1909 1910 /** 1911 * is Integer String 1912 * 1913 * \param 1914 * string 1915 * \return 1916 * true when string is an integer 1917 * false when string is not an integer or string is empty or NULL 1918 */ 1919 typedef bool (*isIntSmallJsonFt) (smallJsont *self); 1920 1921 /** 1922 * convert self to decimal integer 1923 * 1924 * \return 1925 * int64_t 1926 * 0 when smallString represents 0 or doesnt represent a number or the input is NULL 1927 * INT64_MAX or INT64_MIN for strtoll parse errors. 1928 */ 1929 typedef int64_t (*parseIntSmallJsonFt) (smallJsont *self); 1930 1931 /** 1932 * convert self to double 1933 * 1934 * \return 1935 * double 1936 * 0 when smallString represents 0 or doesnt represent a number or the input is NULL 1937 */ 1938 typedef double (*parseDoubleSmallJsonFt) (smallJsont *self); 1939 1940 /** 1941 * int To SmallString 1942 * 1943 * convert int to smallString, assign result to self 1944 * 1945 * \param 1946 * int64_t number 1947 */ 1948 typedef smallJsont* (*intToSmallJsonFt) (smallJsont *self, int64_t n); 1949 1950 /** 1951 * double To String 1952 * 1953 * convert int to string 1954 * 1955 * \param 1956 * double number 1957 */ 1958 typedef smallJsont* (*doubleToSmallJsonFt) (smallJsont *self, double n); 1959 1960 /** 1961 * number of elements 1962 */ 1963 typedef size_t (*lenSmallJsonFt) (smallJsont *self); 1964 1965 /** 1966 * upper case self 1967 */ 1968 typedef smallJsont* (*upperSmallJsonFt) (smallJsont *self); 1969 1970 /** 1971 * lower case self 1972 */ 1973 typedef smallJsont* (*lowerSmallJsonFt) (smallJsont *self); 1974 1975 /** 1976 * remove NULL elements from array 1977 * remove leading and trailing white spaces (spaces and tabs) in smallString 1978 */ 1979 typedef smallJsont* (*trimSmallJsonFt) (smallJsont *self); 1980 typedef smallJsont* (*lTrimSmallJsonFt) (smallJsont *self); 1981 typedef smallJsont* (*rTrimSmallJsonFt) (smallJsont *self); 1982 1983 /** 1984 * list keys 1985 */ 1986 typedef char** (*keysSmallJsonFt) (smallJsont *self); 1987 typedef smallArrayt* (*keysSmallStringSmallJsonFt) (smallJsont *self); 1988 1989 /** 1990 * list values 1991 */ 1992 typedef smallArrayt* (*valuesSmallJsonFt) (smallJsont *self); 1993 1994 /** 1995 * remove empty elements from self 1996 * 1997 * \return 1998 * list without empty elements 1999 * empty list when list is empty 2000 * 0 success 2001 * -1 error 2002 */ 2003 typedef smallJsont* (*compactSmallJsonFt) (smallJsont *self); 2004 2005 /** 2006 * empty 2007 */ 2008 typedef smallJsont* (*emptySmallJsonFt) (smallJsont *self); 2009 2010 /** 2011 * \return 2012 * true when self is empty (len=0) 2013 * false when len > 0 2014 */ 2015 typedef bool (*isEmptySmallJsonFt) (smallJsont *self); 2016 2017 /** 2018 * \return 2019 * true when all elements in self are blank 2020 * false when there is non blank element 2021 */ 2022 typedef bool (*isBlankSmallJsonFt) (smallJsont *self); 2023 2024 /** 2025 * user defined function called in the forEach loop 2026 * this fucntion is a parameter to the forEach function 2027 * 2028 * \param 2029 * closure user defined pointer 2030 * \param 2031 * index index for element 2032 * \param 2033 * element element at index 2034 * \return 2035 * true to continue the loop 2036 * false to break the loop 2037 */ 2038 typedef bool (*forEachElementSmallJsonFt) (void *closure, baset *element); 2039 2040 /** 2041 * for each loop on elements in the Array 2042 * 2043 * \param 2044 * closure user defined pointer 2045 * \param 2046 * funcElem user defined function call on each element 2047 */ 2048 typedef void (*forEachSmallJsonFt) (smallJsont *self, void *closure, forEachElementSmallJsonFt funcElem); 2049 2050 /** 2051 * user defined function called in the enumerate loop 2052 * this fucntion is a parameter to the enumerate function 2053 * 2054 * \param 2055 * closure user defined pointer 2056 * \param 2057 * index index for element 2058 * \param 2059 * element element at index 2060 * \return 2061 * true to continue the loop 2062 * false to break the loop 2063 */ 2064 typedef bool (*enumerateElementSmallJsonFt) (void *closure, size_t index, baset *element); 2065 2066 /** 2067 * enumerate elements in the Array 2068 * 2069 * \param 2070 * closure user defined pointer 2071 * \param 2072 * funcElem user defined function call on each element 2073 */ 2074 typedef void (*enumerateSmallJsonFt) (smallJsont *self, void *closure, enumerateElementSmallJsonFt funcElem); 2075 2076 /** 2077 * user defined function called in the enumerate loop 2078 * this fucntion is a parameter to the enumerate function 2079 * 2080 * \param 2081 * closure user defined pointer 2082 * \param 2083 * key key for element 2084 * \param 2085 * element element for key 2086 * \return 2087 * true to continue the loop 2088 * false to break the loop 2089 */ 2090 typedef bool (*enumerateDictElementSmallJsonFt) (void *closure, char *key, baset *element); 2091 2092 /** 2093 * enumerate elements in the dictionary 2094 * 2095 * \param 2096 * closure user defined pointer 2097 * \param 2098 * funcElem user defined function call on each element 2099 */ 2100 typedef void (*enumerateDictSmallJsonFt) (smallJsont *self, void *closure, enumerateDictElementSmallJsonFt funcElem); 2101 2102 /** 2103 * join list, the elements are seperated with delim in the resulting string 2104 * 2105 * \param 2106 * delim: string seperator 2107 * \return 2108 * joined string 2109 * NULL when list or delim are NULL 2110 */ 2111 typedef smallStringt* (*joinSmallJsonFt) (smallJsont *self, const char* delim); 2112 typedef smallStringt* (*joinCharSmallJsonFt) (smallJsont *self, char c); 2113 typedef smallStringt* (*joinSmallJsonSmallJsonFt) (smallJsont *self, smallJsont* delim); 2114 typedef smallStringt* (*joinSmallStringSmallJsonFt)(smallJsont *self, smallStringt* delim); 2115 2116 /** 2117 * join list, the elements are seperated with delim in the resulting string 2118 * 2119 * \param 2120 * delim: string seperator 2121 * \return 2122 * joined string 2123 * NULL when list or delim are NULL 2124 */ 2125 typedef char* (*joinSSmallJsonFt) (smallJsont *self, const char* delim); 2126 typedef char* (*joinCharSSmallJsonFt) (smallJsont *self, char c); 2127 typedef char* (*joinSmallJsonSSmallJsonFt) (smallJsont *self, smallJsont* delim); 2128 typedef char* (*joinSmallStringSSmallJsonFt)(smallJsont *self, smallStringt* delim); 2129 2130 /** 2131 * split self with delim smallString 2132 * return smallStringArray 2133 * 2134 * \param 2135 * delim delimiter 2136 * \return 2137 * list of tokens 2138 * NULL when list or delim are NULL 2139 */ 2140 typedef smallJsont* (*splitSmallJsonFt) (smallJsont *self, const char *delim); 2141 typedef smallJsont* (*splitCharSmallJsonFt) (smallJsont *self, char c); 2142 typedef smallJsont* (*splitSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *delim); 2143 typedef smallJsont* (*splitSmallStringSmallJsonFt)(smallJsont *self, smallStringt *delim); 2144 2145 /** 2146 * split self with delim smallString 2147 * return list 2148 * 2149 * \param 2150 * delim delimiter 2151 * \return 2152 * list of tokens 2153 * NULL when list or delim are NULL 2154 */ 2155 typedef char** (*splitSSmallJsonFt) (smallJsont *self, const char *delim); 2156 typedef char** (*splitCharSSmallJsonFt) (smallJsont *self, char c); 2157 typedef char** (*splitSmallJsonSSmallJsonFt) (smallJsont *self, smallJsont *delim); 2158 typedef char** (*splitSmallStringSSmallJsonFt) (smallJsont *self, smallStringt *delim); 2159 2160 /** 2161 * extract string between delim1 and delim2 strings 2162 * return list 2163 * 2164 * \param 2165 * string to split 2166 * delim1 first delimiter 2167 * delim2 second delimiter, has to be different from delim1 2168 * \return 2169 * list of tokens 2170 * NULL when list or delim are NULL 2171 */ 2172 typedef smallJsont* (*extractSmallJsonFt) (smallJsont *self, const char* delim1, const char* delim2); 2173 typedef smallJsont* (*extractCharSSmallJsonFt) (smallJsont *self, char delim1, const char* delim2); 2174 typedef smallJsont* (*extractSCharSmallJsonFt) (smallJsont *self, const char* delim1, char delim2); 2175 typedef smallJsont* (*extractCharCharSmallJsonFt)(smallJsont *self, char delim1, char delim2); 2176 typedef smallJsont* (*extractSmallJsonSmallJsonSmallJsonFt) (smallJsont *self, smallJsont* delim1, smallJsont* delim2); 2177 typedef smallJsont* (*extractSmallJsonSmallStringSmallJsonFt) (smallJsont *self, smallJsont* delim1, smallStringt* delim2); 2178 typedef smallJsont* (*extractSmallJsonSSmallJsonFt) (smallJsont *self, smallJsont* delim1, const char* delim2); 2179 typedef smallJsont* (*extractSmallJsonCharSmallJsonFt) (smallJsont *self, smallJsont* delim1, char delim2); 2180 typedef smallJsont* (*extractSmallStringSmallJsonSmallJsonFt) (smallJsont *self, smallStringt* delim1, smallJsont* delim2); 2181 typedef smallJsont* (*extractSmallStringSmallStringSmallJsonFt)(smallJsont *self, smallStringt* delim1, smallStringt* delim2); 2182 typedef smallJsont* (*extractSmallStringSSmallJsonFt) (smallJsont *self, smallStringt* delim1, const char* delim2); 2183 typedef smallJsont* (*extractSmallStringCharSmallJsonFt) (smallJsont *self, smallStringt* delim1, char delim2); 2184 typedef smallJsont* (*extractSSmallJsonSmallJsonFt) (smallJsont *self, const char* delim1, smallJsont* delim2); 2185 typedef smallJsont* (*extractSSmallStringSmallJsonFt) (smallJsont *self, const char* delim1, smallStringt* delim2); 2186 typedef smallJsont* (*extractCharSmallJsonSmallJsonFt) (smallJsont *self, char delim1, smallJsont* delim2); 2187 typedef smallJsont* (*extractCharSmallStringSmallJsonFt) (smallJsont *self, char delim1, smallStringt* delim2); 2188 2189 /** 2190 * ignore case split self with delim smallString 2191 * return smallStringArray 2192 * 2193 * \param 2194 * delim delimiter 2195 * \return 2196 * list of tokens 2197 * NULL when list or delim are NULL 2198 */ 2199 typedef smallJsont* (*icSplitSmallJsonFt) (smallJsont *self, const char *delim); 2200 typedef smallJsont* (*icSplitCharSmallJsonFt) (smallJsont *self, char c); 2201 typedef smallJsont* (*icSplitSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *delim); 2202 typedef smallJsont* (*icSplitSmallStringSmallJsonFt)(smallJsont *self, smallStringt *delim); 2203 2204 /** 2205 * ignore case split self with delim smallString 2206 * return list 2207 * 2208 * \param 2209 * delim delimiter 2210 * \return 2211 * list of tokens 2212 * NULL when list or delim are NULL 2213 */ 2214 typedef char** (*icSplitSSmallJsonFt) (smallJsont *self, const char *delim); 2215 typedef char** (*icSplitCharSSmallJsonFt) (smallJsont *self, char c); 2216 typedef char** (*icSplitSmallJsonSSmallJsonFt) (smallJsont *self, smallJsont *delim); 2217 typedef char** (*icSplitSmallStringSSmallJsonFt) (smallJsont *self, smallStringt *delim); 2218 2219 /** 2220 * ignore case extract string between delim1 and delim2 strings 2221 * return list 2222 * 2223 * \param 2224 * string to split 2225 * delim1 first delimiter 2226 * delim2 second delimiter, has to be different from delim1 2227 * \return 2228 * list of tokens 2229 * NULL when list or delim are NULL 2230 */ 2231 typedef smallJsont* (*icExtractSmallJsonFt) (smallJsont *self, const char* delim1, const char* delim2); 2232 typedef smallJsont* (*icExtractCharSSmallJsonFt) (smallJsont *self, char delim1, const char* delim2); 2233 typedef smallJsont* (*icExtractSCharSmallJsonFt) (smallJsont *self, const char* delim1, char delim2); 2234 typedef smallJsont* (*icExtractCharCharSmallJsonFt)(smallJsont *self, char delim1, char delim2); 2235 typedef smallJsont* (*icExtractSmallJsonSmallJsonSmallJsonFt) (smallJsont *self, smallJsont* delim1, smallJsont* delim2); 2236 typedef smallJsont* (*icExtractSmallJsonSmallStringSmallJsonFt) (smallJsont *self, smallJsont* delim1, smallStringt* delim2); 2237 typedef smallJsont* (*icExtractSmallJsonSSmallJsonFt) (smallJsont *self, smallJsont* delim1, const char* delim2); 2238 typedef smallJsont* (*icExtractSmallJsonCharSmallJsonFt) (smallJsont *self, smallJsont* delim1, char delim2); 2239 typedef smallJsont* (*icExtractSmallStringSmallJsonSmallJsonFt) (smallJsont *self, smallStringt* delim1, smallJsont* delim2); 2240 typedef smallJsont* (*icExtractSmallStringSmallStringSmallJsonFt)(smallJsont *self, smallStringt* delim1, smallStringt* delim2); 2241 typedef smallJsont* (*icExtractSmallStringSSmallJsonFt) (smallJsont *self, smallStringt* delim1, const char* delim2); 2242 typedef smallJsont* (*icExtractSmallStringCharSmallJsonFt) (smallJsont *self, smallStringt* delim1, char delim2); 2243 typedef smallJsont* (*icExtractSSmallJsonSmallJsonFt) (smallJsont *self, const char* delim1, smallJsont* delim2); 2244 typedef smallJsont* (*icExtractSSmallStringSmallJsonFt) (smallJsont *self, const char* delim1, smallStringt* delim2); 2245 typedef smallJsont* (*icExtractCharSmallJsonSmallJsonFt) (smallJsont *self, char delim1, smallJsont* delim2); 2246 typedef smallJsont* (*icExtractCharSmallStringSmallJsonFt) (smallJsont *self, char delim1, smallStringt* delim2); 2247 2248 /** 2249 * color self for terminal 2250 * 2251 * Use the color/effect defines in this file for the color parameter. 2252 * Effects and colors can be combined. 2253 * 2254 * \param 2255 * color color/effect code 2256 */ 2257 typedef smallJsont* (*colorSmallJsonFt) (smallJsont *self, const char *colr); 2258 2259 /** 2260 * color self for terminal 2261 * 2262 * Use the color/effect defines in this file for the color parameter. 2263 * Effects and colors can be combined. 2264 * 2265 * \param 2266 * color color/effect code 2267 * \return 2268 * duplicated self with colors 2269 */ 2270 typedef char* (*colordSmallJsonFt) (smallJsont *self, const char *color); 2271 2272 /** 2273 * zip arrays and store in json 2274 * 2275 * \return 2276 * self all the elements from keys and values are in the json 2277 * (some elements from keys and values are in the json or keys or values length is 0) 2278 * NULL keys or values is NULL 2279 */ 2280 typedef smallJsont* (*zipSmallJsonFt) (smallJsont *self, smallArrayt *array1, smallArrayt *array2); 2281 typedef smallJsont* (*zipArraySmallJsonFt) (smallJsont *self, char** array1, smallArrayt *array2); 2282 typedef smallJsont* (*zipCArraySmallJsonFt) (smallJsont *self, const char** array1, smallArrayt *array2); 2283 typedef smallJsont* (*zipCharSmallJsonFt) (smallJsont *self, smallArrayt *array1, char** array2); 2284 typedef smallJsont* (*zipCCharSmallJsonFt) (smallJsont *self, smallArrayt *array1, const char** array2); 2285 typedef smallJsont* (*zipArrayCharSmallJsonFt) (smallJsont *self, char** array1, char** array2); 2286 typedef smallJsont* (*zipCArrayCharSmallJsonFt) (smallJsont *self, const char** array1, char** array2); 2287 typedef smallJsont* (*zipArrayCCharSmallJsonFt) (smallJsont *self, char** array1, const char** array2); 2288 typedef smallJsont* (*zipCArrayCCharSmallJsonFt)(smallJsont *self, const char** array1, const char** array2); 2289 typedef smallJsont* (*zipJsonSmallJsonFt) (smallJsont *self, smallJsont *array1, smallJsont *array2); 2290 typedef smallJsont* (*zipJsonSmallArraySmallJsonFt)(smallJsont *self, smallJsont *array1, smallArrayt *array2); 2291 typedef smallJsont* (*zipJsonArraySmallJsonFt) (smallJsont *self, smallJsont *array1, char** array2); 2292 typedef smallJsont* (*zipJsonCArraySmallJsonFt) (smallJsont *self, smallJsont *array1, const char** array2); 2293 typedef smallJsont* (*zipSmallArrayJsonSmallJsonFt)(smallJsont *self, smallArrayt *array1, smallJsont *array2); 2294 typedef smallJsont* (*zipArrayJsonSmallJsonFt) (smallJsont *self, char** array1, smallJsont *array2); 2295 typedef smallJsont* (*zipCArrayJsonSmallJsonFt) (smallJsont *self, const char** array1, smallJsont *array2); 2296 2297 /** 2298 * iterator 2299 * 2300 * iterStart resets and starts the iteration 2301 * use iterIndex method to get current index when the json is an array 2302 * use iterKey method to get current key when the json is a dictionary 2303 * 2304 * index and step can be negative (python index) 2305 * 2306 * Example: 2307 * iter(json, e) { 2308 * logVarG(e); 2309 * } 2310 */ 2311 typedef baset* (*iterStartSmallJsonFt) (smallJsont *self); 2312 typedef const char* (*iterStartKeySmallJsonFt) (smallJsont *self); 2313 typedef baset* (*iterStartLastSmallJsonFt) (smallJsont *self); 2314 typedef baset* (*iterStartFromSmallJsonFt) (smallJsont *self, int64_t index); 2315 typedef baset* (*iterStartFromStepSmallJsonFt)(smallJsont *self, int64_t index, int64_t step); 2316 typedef baset* (*iterNextSmallJsonFt) (smallJsont *self); 2317 typedef const char* (*iterNextKeySmallJsonFt) (smallJsont *self); 2318 typedef baset* (*iterElementSmallJsonFt) (smallJsont *self); 2319 typedef const char* (*iterKeySmallJsonFt) (smallJsont *self); 2320 typedef ssize_t (*iterIndexSmallJsonFt) (smallJsont *self); 2321 typedef int64_t (*iterStepSmallJsonFt) (smallJsont *self); 2322 2323 /** 2324 * stringify self 2325 */ 2326 typedef char* (*stringifySmallJsonFt) (smallJsont *self, int indent); 2327 typedef smallStringt* (*stringifySmallStringSmallJsonFt) (smallJsont *self, int indent); 2328 2329 /** 2330 * stringify self to yml format 2331 */ 2332 typedef char* (*toYMLSmallJsonFt) (smallJsont *self, int indent); 2333 typedef smallStringt* (*toYMLSmallStringSmallJsonFt) (smallJsont *self, int indent); 2334 2335 /** 2336 * parse a smallJson string 2337 */ 2338 typedef bool (*parseSmallJsonFt) (smallJsont *self, const char *input); 2339 typedef bool (*parseSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *input); 2340 typedef bool (*parseSmallStringSmallJsonFt)(smallJsont *self, smallStringt *input); 2341 2342 /** 2343 * parse a yml string 2344 */ 2345 typedef bool (*parseYMLSmallJsonFt) (smallJsont *self, const char *input); 2346 typedef bool (*parseYMLSmallJsonSmallJsonFt) (smallJsont *self, smallJsont *input); 2347 typedef bool (*parseYMLSmallStringSmallJsonFt)(smallJsont *self, smallStringt *input); 2348 2349 /** 2350 * serialize self data 2351 * 2352 * \return 2353 * smallBytest object holding the binary data representing self 2354 */ 2355 typedef smallBytest* (*serialSmallJsonFt) (smallJsont *self); 2356 2357 /** 2358 * deserialize data and set objects in self 2359 * 2360 * self is freed before the data is deseriablized 2361 * 2362 * \param 2363 * data binary data representing a json object 2364 */ 2365 typedef smallJsont* (*deserialSmallJsonFt)(smallJsont *self, smallBytest *data); 2366 2367 /** 2368 * print json content to stdout 2369 */ 2370 typedef void (*logSmallJsonFt) (smallJsont *self); 2371 2372 /** 2373 * read file to json 2374 * 2375 * the format is selected using the file extension (json or yml) 2376 * 2377 * \param 2378 * filePath: path to file 2379 * \return 2380 * 0 data in file 2381 * -1 an error occured 2382 */ 2383 typedef smallJsont* (*readFileSmallJsonFt) (smallJsont *self, const char *filePath); 2384 typedef smallJsont* (*readFileSmallStringSmallJsonFt)(smallJsont *self, smallStringt *filePath); 2385 typedef smallJsont* (*readFileJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2386 2387 /** 2388 * read stream to json 2389 * 2390 * the format is assumed to be json 2391 * 2392 * \param 2393 * file pointer 2394 * \return 2395 * 0 data in file 2396 * -1 an error occured 2397 */ 2398 typedef smallJsont* (*readStreamSmallJsonFt)(smallJsont *self, FILE *fp); 2399 2400 /** 2401 * write json to file 2402 * 2403 * the format is selected using the file extension (json or yml) 2404 * 2405 * \param 2406 * filePath path to file 2407 * string 2408 * \return 2409 * 1 success 2410 * 0 error 2411 */ 2412 typedef int (*writeFileSmallJsonFt) (smallJsont *self, const char *filePath); 2413 typedef int (*writeFileSmallStringSmallJsonFt)(smallJsont *self, smallStringt *filePath); 2414 typedef int (*writeFileJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2415 2416 /** 2417 * write json to file 2418 * 2419 * the format is assumed to be json 2420 * 2421 * \param 2422 * file pointer 2423 * string 2424 * \return 2425 * 1 success 2426 * 0 error 2427 */ 2428 typedef int (*writeStreamSmallJsonFt)(smallJsont *self, FILE *fp); 2429 2430 /** 2431 * append json to filePath 2432 * 2433 * \param 2434 * filePath 2435 * list 2436 * \return 2437 * true success 2438 * false failed, filePath or json are NULL 2439 */ 2440 typedef int (*appendFileSmallJsonFt) (smallJsont *self, const char *filePath); 2441 typedef int (*appendFileSmallStringSmallJsonFt)(smallJsont *self, smallStringt *filePath); 2442 typedef int (*appendFileJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2443 2444 /** 2445 * read text from filePath to self 2446 * new line characters are removed 2447 * 2448 * \param 2449 * filePath: file path 2450 * \return 2451 * lines in list 2452 * empty list when the file is empty 2453 * -1 on failure 2454 */ 2455 typedef smallJsont* (*readTextSmallJsonFt) (smallJsont *self, const char *filePath); 2456 typedef smallJsont* (*readTextSmallStringSmallJsonFt) (smallJsont *self, smallStringt *filePath); 2457 typedef smallJsont* (*readTextJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2458 2459 /** 2460 * return text from stream fp in a list 2461 * new line characters are removed 2462 * 2463 * \param 2464 * fp: file stream 2465 * \return 2466 * lines in list 2467 * empty list when there is no data in the stream 2468 * NULL on failure 2469 */ 2470 typedef smallJsont* (*readTextStreamSmallJsonFt) (smallJsont *self, FILE *fp); 2471 2472 /** 2473 * write Json to filePath 2474 * 2475 * \param 2476 * filePath 2477 * \return 2478 * true success 2479 * false failed, filePath or list are NULL 2480 */ 2481 typedef bool (*writeTextSmallJsonFt) (smallJsont *self, const char *filePath); 2482 typedef bool (*writeTextSmallStringSmallJsonFt) (smallJsont *self, smallStringt *filePath); 2483 typedef bool (*writeTextJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2484 2485 /** 2486 * write list to stream 2487 * 2488 * \param 2489 * fp: file stream 2490 * list 2491 * \return 2492 * true success 2493 * false failed, fp or list are NULL 2494 */ 2495 typedef bool (*writeTextStreamSmallJsonFt) (smallJsont *self, FILE *fp); 2496 2497 /** 2498 * append list to filePath 2499 * 2500 * \param 2501 * filePath 2502 * list 2503 * \return 2504 * true success 2505 * false failed, filePath or list are NULL 2506 */ 2507 typedef bool (*appendTextSmallJsonFt) (smallJsont *self, const char *filePath); 2508 typedef bool (*appendTextSmallStringSmallJsonFt)(smallJsont *self, smallStringt *filePath); 2509 typedef bool (*appendTextJsonSmallJsonFt) (smallJsont *self, smallJsont *filePath); 2510 2511 /** 2512 * get object type string for key or index 2513 * 2514 * \param 2515 * key in dictionary or index in array 2516 * \return 2517 * object type string 2518 */ 2519 typedef const char* (*typeStringSmallJsonFt) (smallJsont *self, const char *key); 2520 typedef smallStringt* (*typeSmallStringSmallJsonFt) (smallJsont *self, const char *key); 2521 typedef const char* (*typeAtStringSmallJsonFt) (smallJsont *self, int64_t index); 2522 typedef smallStringt* (*typeAtSmallStringSmallJsonFt) (smallJsont *self, int64_t index); 2523 2524 typedef const char* (*typeStringKCharSmallJsonFt) (smallJsont *self, char key); 2525 typedef smallStringt* (*typeSmallStringKCharSmallJsonFt)(smallJsont *self, char key); 2526 2527 /** 2528 * get object type for key or index 2529 * 2530 * \param 2531 * key in dictionary or index in array 2532 * \return 2533 * object type 2534 */ 2535 typedef char (*typeSmallJsonFt) (smallJsont *self, const char *key); 2536 typedef char (*typeKCharSmallJsonFt) (smallJsont *self, char key); 2537 typedef char (*typeAtSmallJsonFt) (smallJsont *self, int64_t index); 2538 2539 /** 2540 * get first level of object type string in json 2541 * 2542 * \return 2543 * array or dictionary of object type strings 2544 */ 2545 typedef smallJsont* (*typeStringsSmallJsonFt)(smallJsont *self); 2546 2547 /** 2548 * get first level of object type in array 2549 * 2550 * \return 2551 * smallBytes list of object type 2552 */ 2553 typedef smallBytest* (*typesSmallJsonFt) (smallJsont *self); 2554 2555 /** 2556 * is element at index of type type 2557 */ 2558 typedef bool (*isETypeAtSmallJsonFt) (smallJsont *self, int64_t index, const char *type); 2559 typedef bool (*isEUndefinedAtSmallJsonFt) (smallJsont *self, int64_t index); 2560 typedef bool (*isEBoolAtSmallJsonFt) (smallJsont *self, int64_t index); 2561 typedef bool (*isEContainerAtSmallJsonFt) (smallJsont *self, int64_t index); 2562 typedef bool (*isEDictAtSmallJsonFt) (smallJsont *self, int64_t index); 2563 typedef bool (*isEDoubleAtSmallJsonFt) (smallJsont *self, int64_t index); 2564 typedef bool (*isEIntAtSmallJsonFt) (smallJsont *self, int64_t index); 2565 typedef bool (*isEStringAtSmallJsonFt) (smallJsont *self, int64_t index); 2566 typedef bool (*isEFaststringAtSmallJsonFt)(smallJsont *self, int64_t index); 2567 typedef bool (*isEArrayAtSmallJsonFt) (smallJsont *self, int64_t index); 2568 typedef bool (*isEBytesAtSmallJsonFt) (smallJsont *self, int64_t index); 2569 2570 /** 2571 * is element at key of type type 2572 */ 2573 typedef bool (*isETypeSmallJsonFt) (smallJsont *self, const char *key, const char *type); 2574 typedef bool (*isEUndefinedSmallJsonFt) (smallJsont *self, const char *key); 2575 typedef bool (*isEBoolSmallJsonFt) (smallJsont *self, const char *key); 2576 typedef bool (*isEContainerSmallJsonFt) (smallJsont *self, const char *key); 2577 typedef bool (*isEDictSmallJsonFt) (smallJsont *self, const char *key); 2578 typedef bool (*isEDoubleSmallJsonFt) (smallJsont *self, const char *key); 2579 typedef bool (*isEIntSmallJsonFt) (smallJsont *self, const char *key); 2580 typedef bool (*isEStringSmallJsonFt) (smallJsont *self, const char *key); 2581 typedef bool (*isEFaststringSmallJsonFt)(smallJsont *self, const char *key); 2582 typedef bool (*isEArraySmallJsonFt) (smallJsont *self, const char *key); 2583 typedef bool (*isEBytesSmallJsonFt) (smallJsont *self, const char *key); 2584 2585 /** 2586 * are all elements of type type 2587 */ 2588 typedef bool (*areAllETypeSmallJsonFt) (smallJsont *self, const char *type); 2589 typedef bool (*areAllEUndefinedSmallJsonFt) (smallJsont *self); 2590 typedef bool (*areAllEBoolSmallJsonFt) (smallJsont *self); 2591 typedef bool (*areAllEContainerSmallJsonFt) (smallJsont *self); 2592 typedef bool (*areAllEDictSmallJsonFt) (smallJsont *self); 2593 typedef bool (*areAllEDoubleSmallJsonFt) (smallJsont *self); 2594 typedef bool (*areAllEIntSmallJsonFt) (smallJsont *self); 2595 typedef bool (*areAllEStringSmallJsonFt) (smallJsont *self); 2596 typedef bool (*areAllEFaststringSmallJsonFt)(smallJsont *self); 2597 typedef bool (*areAllEArraySmallJsonFt) (smallJsont *self); 2598 typedef bool (*areAllEBytesSmallJsonFt) (smallJsont *self); 2599 2600 /** 2601 * class functions 2602 * allocated once for all objects 2603 * 2604 * freed with finalizeSmallJson or finalizeLibsheepy 2605 */ 2606 2607 /** 2608 * use this define in child classes and add the new function after this class functions 2609 * 2610 * in this define, add the methods after <finishClassTemplateFt finish;> 2611 * 2612 * Example: 2613 * #define RINGFUNCTIONST \ 2614 * CLASSTEMPLATEFUNCTIONST; \ 2615 * setSizeRingFt setSize 2616 * 2617 * not used, included in mergeSmallJson: 2618 * appendSmallJsonSmallJsonFt appendSmallJson;\ 2619 * appendSmallJsonNSmashSmallJsonFt appendSmallJsonNSmash;\ 2620 */ 2621 #define SMALLJSONFUNCTIONST \ 2622 helpSmallJsonFt help;\ 2623 escapeSmallJsonFt escape;\ 2624 disposeSmallJsonFt dispose;\ 2625 resetSmallJsonFt reset;\ 2626 getsoSmallJsonFt getso;\ 2627 setsoSmallJsonFt setso;\ 2628 mirrorSmallJsonFt mirror;\ 2629 getTopTypeSmallJsonFt getTopType;\ 2630 setTypeUndefinedSmallJsonFt setTypeUndefined;\ 2631 setTypeBoolSmallJsonFt setTypeBool;\ 2632 setTypeDoubleSmallJsonFt setTypeDouble;\ 2633 setTypeIntSmallJsonFt setTypeInt;\ 2634 setTypeStringSmallJsonFt setTypeString;\ 2635 setTypeDictSmallJsonFt setTypeDict;\ 2636 setTypeArraySmallJsonFt setTypeArray;\ 2637 setTopSmallJsonFt setTop;\ 2638 setTopBoolSmallJsonFt setTopBool;\ 2639 setTopDoubleSmallJsonFt setTopDouble;\ 2640 setTopIntSmallJsonFt setTopInt;\ 2641 setTopStringSmallJsonFt setTopString;\ 2642 setTopCharSmallJsonFt setTopChar;\ 2643 setTopDictSmallJsonFt setTopDict;\ 2644 setTopArraySmallJsonFt setTopArray;\ 2645 setTopArraycSmallJsonFt setTopArrayc;\ 2646 setTopCArraycSmallJsonFt setTopCArrayc;\ 2647 setTopSmallBoolSmallJsonFt setTopSmallBool;\ 2648 setTopSmallDoubleSmallJsonFt setTopSmallDouble;\ 2649 setTopSmallIntSmallJsonFt setTopSmallInt;\ 2650 setTopSmallJsonSmallJsonFt setTopSmallJson;\ 2651 setTopSmallStringSmallJsonFt setTopSmallString;\ 2652 setTopNFreeSmallJsonFt setTopNFree;\ 2653 setTopNFreeBoolSmallJsonFt setTopNFreeBool;\ 2654 setTopNFreeDoubleSmallJsonFt setTopNFreeDouble;\ 2655 setTopNFreeIntSmallJsonFt setTopNFreeInt;\ 2656 setTopNFreeStringSmallJsonFt setTopNFreeString;\ 2657 setTopNFreeDictSmallJsonFt setTopNFreeDict;\ 2658 setTopNFreeArraySmallJsonFt setTopNFreeArray;\ 2659 setTopNFreeArraycSmallJsonFt setTopNFreeArrayc;\ 2660 setTopNFreeSmallBoolSmallJsonFt setTopNFreeSmallBool;\ 2661 setTopNFreeSmallDoubleSmallJsonFt setTopNFreeSmallDouble;\ 2662 setTopNFreeSmallIntSmallJsonFt setTopNFreeSmallInt;\ 2663 setTopNFreeSmallJsonSmallJsonFt setTopNFreeSmallJson;\ 2664 setTopNFreeSmallStringSmallJsonFt setTopNFreeSmallString;\ 2665 fromArraySmallJsonFt fromArray;\ 2666 fromCArraySmallJsonFt fromCArray;\ 2667 fromArrayNFreeSmallJsonFt fromArrayNFree;\ 2668 fromArrayDictSmallJsonFt fromArrayDict;\ 2669 toArrayDictSmallJsonFt toArrayDict;\ 2670 getTopSmallJsonFt getTop;\ 2671 getTopUndefinedSmallJsonFt getTopUndefined;\ 2672 getTopBoolSmallJsonFt getTopBool;\ 2673 getTopBoolPSmallJsonFt getTopBoolP;\ 2674 getTopDoubleSmallJsonFt getTopDouble;\ 2675 getTopDoublePSmallJsonFt getTopDoubleP;\ 2676 getTopIntSmallJsonFt getTopInt;\ 2677 getTopIntPSmallJsonFt getTopIntP;\ 2678 getTopInt32SmallJsonFt getTopInt32;\ 2679 getTopInt32PSmallJsonFt getTopInt32P;\ 2680 getTopUintSmallJsonFt getTopUint;\ 2681 getTopUintPSmallJsonFt getTopUintP;\ 2682 getTopUint32SmallJsonFt getTopUint32;\ 2683 getTopUint32PSmallJsonFt getTopUint32P;\ 2684 getTopSSmallJsonFt getTopS;\ 2685 getTopDictSmallJsonFt getTopDict;\ 2686 getTopArraySmallJsonFt getTopArray;\ 2687 getTopSmallBoolSmallJsonFt getTopSmallBool;\ 2688 getTopSmallDoubleSmallJsonFt getTopSmallDouble;\ 2689 getTopSmallIntSmallJsonFt getTopSmallInt;\ 2690 getTopSmallStringSmallJsonFt getTopSmallString;\ 2691 keyIsSmallJsonFt keyIs;\ 2692 keyIsSSmallJsonFt keyIsS;\ 2693 makeKeySmallJsonFt makeKey;\ 2694 iMakeKeySmallJsonFt iMakeKey;\ 2695 bMakeKeySmallJsonFt bMakeKey;\ 2696 bLMakeKeySmallJsonFt bLMakeKey;\ 2697 makeKeyLenSmallJsonFt makeKeyLen;\ 2698 setSmallJsonFt set;\ 2699 setUndefinedSmallJsonFt setUndefined;\ 2700 setBoolSmallJsonFt setBool;\ 2701 setDoubleSmallJsonFt setDouble;\ 2702 setIntSmallJsonFt setInt;\ 2703 setSSmallJsonFt setS;\ 2704 setCharSmallJsonFt setChar;\ 2705 setDictSmallJsonFt setDict;\ 2706 setArraySmallJsonFt setArray;\ 2707 setArraycSmallJsonFt setArrayc;\ 2708 setCArraycSmallJsonFt setCArrayc;\ 2709 setSmallBoolSmallJsonFt setSmallBool;\ 2710 setSmallBytesSmallJsonFt setSmallBytes;\ 2711 setSmallDoubleSmallJsonFt setSmallDouble;\ 2712 setSmallIntSmallJsonFt setSmallInt;\ 2713 setSmallJsonSmallJsonFt setSmallJson;\ 2714 setSmallStringSmallJsonFt setSmallString;\ 2715 setSmallContainerSmallJsonFt setSmallContainer;\ 2716 setNFreeSmallJsonFt setNFree;\ 2717 setNFreeUndefinedSmallJsonFt setNFreeUndefined;\ 2718 setNFreeSSmallJsonFt setNFreeS;\ 2719 setNFreeDictSmallJsonFt setNFreeDict;\ 2720 setNFreeArraySmallJsonFt setNFreeArray;\ 2721 setNFreeArraycSmallJsonFt setNFreeArrayc;\ 2722 setNFreeSmallBoolSmallJsonFt setNFreeSmallBool;\ 2723 setNFreeSmallBytesSmallJsonFt setNFreeSmallBytes;\ 2724 setNFreeSmallDoubleSmallJsonFt setNFreeSmallDouble;\ 2725 setNFreeSmallIntSmallJsonFt setNFreeSmallInt;\ 2726 setNFreeSmallJsonSmallJsonFt setNFreeSmallJson;\ 2727 setNFreeSmallStringSmallJsonFt setNFreeSmallString;\ 2728 setNFreeSmallContainerSmallJsonFt setNFreeSmallContainer;\ 2729 setPDictSmallJsonFt setPDict;\ 2730 setPArraySmallJsonFt setPArray;\ 2731 setPSmallJsonSmallJsonFt setPSmallJson;\ 2732 setPSmallStringSmallJsonFt setPSmallString;\ 2733 setNFreePDictSmallJsonFt setNFreePDict;\ 2734 setNFreePArraySmallJsonFt setNFreePArray;\ 2735 setNFreePSmallJsonSmallJsonFt setNFreePSmallJson;\ 2736 setNFreePSmallStringSmallJsonFt setNFreePSmallString;\ 2737 setAtSmallJsonFt setAt;\ 2738 setAtUndefinedSmallJsonFt setAtUndefined;\ 2739 setAtBoolSmallJsonFt setAtBool;\ 2740 setAtDoubleSmallJsonFt setAtDouble;\ 2741 setAtIntSmallJsonFt setAtInt;\ 2742 setAtSSmallJsonFt setAtS;\ 2743 setAtCharSmallJsonFt setAtChar;\ 2744 setAtDictSmallJsonFt setAtDict;\ 2745 setAtArraySmallJsonFt setAtArray;\ 2746 setAtArraycSmallJsonFt setAtArrayc;\ 2747 setAtCArraycSmallJsonFt setAtCArrayc;\ 2748 setAtSmallBoolSmallJsonFt setAtSmallBool;\ 2749 setAtSmallBytesSmallJsonFt setAtSmallBytes;\ 2750 setAtSmallDoubleSmallJsonFt setAtSmallDouble;\ 2751 setAtSmallIntSmallJsonFt setAtSmallInt;\ 2752 setAtSmallJsonSmallJsonFt setAtSmallJson;\ 2753 setAtSmallStringSmallJsonFt setAtSmallString;\ 2754 setAtSmallContainerSmallJsonFt setAtSmallContainer;\ 2755 setAtNFreeSmallJsonFt setAtNFree;\ 2756 setAtNFreeUndefinedSmallJsonFt setAtNFreeUndefined;\ 2757 setAtNFreeSSmallJsonFt setAtNFreeS;\ 2758 setAtNFreeDictSmallJsonFt setAtNFreeDict;\ 2759 setAtNFreeArraySmallJsonFt setAtNFreeArray;\ 2760 setAtNFreeArraycSmallJsonFt setAtNFreeArrayc;\ 2761 setAtNFreeSmallBoolSmallJsonFt setAtNFreeSmallBool;\ 2762 setAtNFreeSmallBytesSmallJsonFt setAtNFreeSmallBytes;\ 2763 setAtNFreeSmallDoubleSmallJsonFt setAtNFreeSmallDouble;\ 2764 setAtNFreeSmallIntSmallJsonFt setAtNFreeSmallInt;\ 2765 setAtNFreeSmallJsonSmallJsonFt setAtNFreeSmallJson;\ 2766 setAtNFreeSmallStringSmallJsonFt setAtNFreeSmallString;\ 2767 setAtNFreeSmallContainerSmallJsonFt setAtNFreeSmallContainer;\ 2768 setPAtArraySmallJsonFt setPAtArray;\ 2769 setPAtDictSmallJsonFt setPAtDict;\ 2770 setPAtSmallJsonSmallJsonFt setPAtSmallJson;\ 2771 setPAtSmallStringSmallJsonFt setPAtSmallString;\ 2772 setPAtNFreeArraySmallJsonFt setPAtNFreeArray;\ 2773 setPAtNFreeDictSmallJsonFt setPAtNFreeDict;\ 2774 setPAtNFreeSmallJsonSmallJsonFt setPAtNFreeSmallJson;\ 2775 setPAtNFreeSmallStringSmallJsonFt setPAtNFreeSmallString;\ 2776 getSmallJsonFt get;\ 2777 getUndefinedSmallJsonFt getUndefined;\ 2778 getBoolSmallJsonFt getBool;\ 2779 getBoolPSmallJsonFt getBoolP;\ 2780 getDoubleSmallJsonFt getDouble;\ 2781 getDoublePSmallJsonFt getDoubleP;\ 2782 getIntSmallJsonFt getInt;\ 2783 getIntPSmallJsonFt getIntP;\ 2784 getInt32SmallJsonFt getInt32;\ 2785 getInt32PSmallJsonFt getInt32P;\ 2786 getUintSmallJsonFt getUint;\ 2787 getUintPSmallJsonFt getUintP;\ 2788 getUint32SmallJsonFt getUint32;\ 2789 getUint32PSmallJsonFt getUint32P;\ 2790 getSSmallJsonFt getS;\ 2791 getDictSmallJsonFt getDict;\ 2792 getArraySmallJsonFt getArray;\ 2793 getSmallBoolSmallJsonFt getSmallBool;\ 2794 getSmallBytesSmallJsonFt getSmallBytes;\ 2795 getSmallDoubleSmallJsonFt getSmallDouble;\ 2796 getSmallIntSmallJsonFt getSmallInt;\ 2797 getSmallJsonSmallJsonFt getSmallJson;\ 2798 getSmallStringSmallJsonFt getSmallString;\ 2799 getVoidSmallJsonFt getVoid;\ 2800 getSmallContainerSmallJsonFt getSmallContainer;\ 2801 getNDupSmallJsonFt getNDup;\ 2802 getNDupUndefinedSmallJsonFt getNDupUndefined;\ 2803 getNDupBoolSmallJsonFt getNDupBool;\ 2804 getNDupDoubleSmallJsonFt getNDupDouble;\ 2805 getNDupIntSmallJsonFt getNDupInt;\ 2806 getNDupInt32SmallJsonFt getNDupInt32;\ 2807 getNDupUintSmallJsonFt getNDupUint;\ 2808 getNDupUint32SmallJsonFt getNDupUint32;\ 2809 getNDupSSmallJsonFt getNDupS;\ 2810 getNDupDictSmallJsonFt getNDupDict;\ 2811 getNDupArraySmallJsonFt getNDupArray;\ 2812 getNDupSmallBoolSmallJsonFt getNDupSmallBool;\ 2813 getNDupSmallBytesSmallJsonFt getNDupSmallBytes;\ 2814 getNDupSmallDoubleSmallJsonFt getNDupSmallDouble;\ 2815 getNDupSmallIntSmallJsonFt getNDupSmallInt;\ 2816 getNDupSmallJsonSmallJsonFt getNDupSmallJson;\ 2817 getNDupSmallStringSmallJsonFt getNDupSmallString;\ 2818 getNDupVoidSmallJsonFt getNDupVoid;\ 2819 getNDupSmallContainerSmallJsonFt getNDupSmallContainer;\ 2820 getAtSmallJsonFt getAt;\ 2821 getAtUndefinedSmallJsonFt getAtUndefined;\ 2822 getAtBoolSmallJsonFt getAtBool;\ 2823 getAtBoolPSmallJsonFt getAtBoolP;\ 2824 getAtDoubleSmallJsonFt getAtDouble;\ 2825 getAtDoublePSmallJsonFt getAtDoubleP;\ 2826 getAtIntSmallJsonFt getAtInt;\ 2827 getAtIntPSmallJsonFt getAtIntP;\ 2828 getAtInt32SmallJsonFt getAtInt32;\ 2829 getAtInt32PSmallJsonFt getAtInt32P;\ 2830 getAtUintSmallJsonFt getAtUint;\ 2831 getAtUintPSmallJsonFt getAtUintP;\ 2832 getAtUint32SmallJsonFt getAtUint32;\ 2833 getAtUint32PSmallJsonFt getAtUint32P;\ 2834 getAtSSmallJsonFt getAtS;\ 2835 getAtDictSmallJsonFt getAtDict;\ 2836 getAtArraySmallJsonFt getAtArray;\ 2837 getAtSmallBoolSmallJsonFt getAtSmallBool;\ 2838 getAtSmallBytesSmallJsonFt getAtSmallBytes;\ 2839 getAtSmallDoubleSmallJsonFt getAtSmallDouble;\ 2840 getAtSmallIntSmallJsonFt getAtSmallInt;\ 2841 getAtSmallJsonSmallJsonFt getAtSmallJson;\ 2842 getAtSmallStringSmallJsonFt getAtSmallString;\ 2843 getAtVoidSmallJsonFt getAtVoid;\ 2844 getAtSmallContainerSmallJsonFt getAtSmallContainer;\ 2845 getAtNDupSmallJsonFt getAtNDup;\ 2846 getAtNDupUndefinedSmallJsonFt getAtNDupUndefined;\ 2847 getAtNDupBoolSmallJsonFt getAtNDupBool;\ 2848 getAtNDupDoubleSmallJsonFt getAtNDupDouble;\ 2849 getAtNDupIntSmallJsonFt getAtNDupInt;\ 2850 getAtNDupInt32SmallJsonFt getAtNDupInt32;\ 2851 getAtNDupUintSmallJsonFt getAtNDupUint;\ 2852 getAtNDupUint32SmallJsonFt getAtNDupUint32;\ 2853 getAtNDupSSmallJsonFt getAtNDupS;\ 2854 getAtNDupDictSmallJsonFt getAtNDupDict;\ 2855 getAtNDupArraySmallJsonFt getAtNDupArray;\ 2856 getAtNDupSmallBoolSmallJsonFt getAtNDupSmallBool;\ 2857 getAtNDupSmallBytesSmallJsonFt getAtNDupSmallBytes;\ 2858 getAtNDupSmallDoubleSmallJsonFt getAtNDupSmallDouble;\ 2859 getAtNDupSmallIntSmallJsonFt getAtNDupSmallInt;\ 2860 getAtNDupSmallJsonSmallJsonFt getAtNDupSmallJson;\ 2861 getAtNDupSmallStringSmallJsonFt getAtNDupSmallString;\ 2862 getAtNDupVoidSmallJsonFt getAtNDupVoid;\ 2863 getAtNDupSmallContainerSmallJsonFt getAtNDupSmallContainer;\ 2864 getNumSmallJsonFt getNum;\ 2865 getNumAtSmallJsonFt getNumAt;\ 2866 delElemSmallJsonFt delElem;\ 2867 delSmallJsonFt del;\ 2868 delElemIndexSmallJsonFt delElemIndex;\ 2869 removeElemSmallJsonFt removeElem;\ 2870 removeSmallJsonFt remove;\ 2871 removeElemIndexSmallJsonFt removeElemIndex;\ 2872 pushSmallJsonFt push;\ 2873 pushUndefinedSmallJsonFt pushUndefined;\ 2874 pushBoolSmallJsonFt pushBool;\ 2875 pushDoubleSmallJsonFt pushDouble;\ 2876 pushIntSmallJsonFt pushInt;\ 2877 pushSSmallJsonFt pushS;\ 2878 pushCharSmallJsonFt pushChar;\ 2879 pushDictSmallJsonFt pushDict;\ 2880 pushArraySmallJsonFt pushArray;\ 2881 pushArraycSmallJsonFt pushArrayc;\ 2882 pushCArraycSmallJsonFt pushCArrayc;\ 2883 pushSmallBoolSmallJsonFt pushSmallBool;\ 2884 pushSmallBytesSmallJsonFt pushSmallBytes;\ 2885 pushSmallDoubleSmallJsonFt pushSmallDouble;\ 2886 pushSmallIntSmallJsonFt pushSmallInt;\ 2887 pushSmallJsonSmallJsonFt pushSmallJson;\ 2888 pushSmallStringSmallJsonFt pushSmallString;\ 2889 pushSmallContainerSmallJsonFt pushSmallContainer;\ 2890 pushNFreeSmallJsonFt pushNFree;\ 2891 pushNFreeUndefinedSmallJsonFt pushNFreeUndefined;\ 2892 pushNFreeSSmallJsonFt pushNFreeS;\ 2893 pushNFreeDictSmallJsonFt pushNFreeDict;\ 2894 pushNFreeArraySmallJsonFt pushNFreeArray;\ 2895 pushNFreeArraycSmallJsonFt pushNFreeArrayc;\ 2896 pushNFreeSmallBoolSmallJsonFt pushNFreeSmallBool;\ 2897 pushNFreeSmallBytesSmallJsonFt pushNFreeSmallBytes;\ 2898 pushNFreeSmallDoubleSmallJsonFt pushNFreeSmallDouble;\ 2899 pushNFreeSmallIntSmallJsonFt pushNFreeSmallInt;\ 2900 pushNFreeSmallJsonSmallJsonFt pushNFreeSmallJson;\ 2901 pushNFreeSmallStringSmallJsonFt pushNFreeSmallString;\ 2902 pushNFreeSmallContainerSmallJsonFt pushNFreeSmallContainer;\ 2903 pushManySmallJsonFt pushMany;\ 2904 pushManySSmallJsonFt pushManyS;\ 2905 pushManySSmallJsonFt catSt;\ 2906 pushNFreeManySmallJsonFt pushNFreeMany;\ 2907 pushNFreeManySSmallJsonFt pushNFreeManyS;\ 2908 popSmallJsonFt pop;\ 2909 popUndefinedSmallJsonFt popUndefined;\ 2910 popBoolSmallJsonFt popBool;\ 2911 popDoubleSmallJsonFt popDouble;\ 2912 popIntSmallJsonFt popInt;\ 2913 popInt32SmallJsonFt popInt32;\ 2914 popUintSmallJsonFt popUint;\ 2915 popUint32SmallJsonFt popUint32;\ 2916 popSSmallJsonFt popS;\ 2917 popDictSmallJsonFt popDict;\ 2918 popArraySmallJsonFt popArray;\ 2919 popSmallBoolSmallJsonFt popSmallBool;\ 2920 popSmallBytesSmallJsonFt popSmallBytes;\ 2921 popSmallDoubleSmallJsonFt popSmallDouble;\ 2922 popSmallIntSmallJsonFt popSmallInt;\ 2923 popSmallJsonSmallJsonFt popSmallJson;\ 2924 popSmallStringSmallJsonFt popSmallString;\ 2925 popVoidSmallJsonFt popVoid;\ 2926 popSmallContainerSmallJsonFt popSmallContainer;\ 2927 popNumSmallJsonFt popNum;\ 2928 prependSmallJsonFt prepend;\ 2929 prependUndefinedSmallJsonFt prependUndefined;\ 2930 prependBoolSmallJsonFt prependBool;\ 2931 prependDoubleSmallJsonFt prependDouble;\ 2932 prependIntSmallJsonFt prependInt;\ 2933 prependSSmallJsonFt prependS;\ 2934 prependCharSmallJsonFt prependChar;\ 2935 prependDictSmallJsonFt prependDict;\ 2936 prependArraySmallJsonFt prependArray;\ 2937 prependArraycSmallJsonFt prependArrayc;\ 2938 prependCArraycSmallJsonFt prependCArrayc;\ 2939 prependSmallBoolSmallJsonFt prependSmallBool;\ 2940 prependSmallBytesSmallJsonFt prependSmallBytes;\ 2941 prependSmallDoubleSmallJsonFt prependSmallDouble;\ 2942 prependSmallIntSmallJsonFt prependSmallInt;\ 2943 prependSmallJsonSmallJsonFt prependSmallJson;\ 2944 prependSmallStringSmallJsonFt prependSmallString;\ 2945 prependSmallContainerSmallJsonFt prependSmallContainer;\ 2946 prependNFreeSmallJsonFt prependNFree;\ 2947 prependNFreeUndefinedSmallJsonFt prependNFreeUndefined;\ 2948 prependNFreeSSmallJsonFt prependNFreeS;\ 2949 prependNFreeDictSmallJsonFt prependNFreeDict;\ 2950 prependNFreeArraySmallJsonFt prependNFreeArray;\ 2951 prependNFreeArraycSmallJsonFt prependNFreeArrayc;\ 2952 prependNFreeSmallBoolSmallJsonFt prependNFreeSmallBool;\ 2953 prependNFreeSmallBytesSmallJsonFt prependNFreeSmallBytes;\ 2954 prependNFreeSmallDoubleSmallJsonFt prependNFreeSmallDouble;\ 2955 prependNFreeSmallIntSmallJsonFt prependNFreeSmallInt;\ 2956 prependNFreeSmallJsonSmallJsonFt prependNFreeSmallJson;\ 2957 prependNFreeSmallStringSmallJsonFt prependNFreeSmallString;\ 2958 prependNFreeSmallContainerSmallJsonFt prependNFreeSmallContainer;\ 2959 dequeueSmallJsonFt dequeue;\ 2960 dequeueUndefinedSmallJsonFt dequeueUndefined;\ 2961 dequeueBoolSmallJsonFt dequeueBool;\ 2962 dequeueDoubleSmallJsonFt dequeueDouble;\ 2963 dequeueIntSmallJsonFt dequeueInt;\ 2964 dequeueInt32SmallJsonFt dequeueInt32;\ 2965 dequeueUintSmallJsonFt dequeueUint;\ 2966 dequeueUint32SmallJsonFt dequeueUint32;\ 2967 dequeueSSmallJsonFt dequeueS;\ 2968 dequeueDictSmallJsonFt dequeueDict;\ 2969 dequeueArraySmallJsonFt dequeueArray;\ 2970 dequeueSmallBoolSmallJsonFt dequeueSmallBool;\ 2971 dequeueSmallBytesSmallJsonFt dequeueSmallBytes;\ 2972 dequeueSmallDoubleSmallJsonFt dequeueSmallDouble;\ 2973 dequeueSmallIntSmallJsonFt dequeueSmallInt;\ 2974 dequeueSmallJsonSmallJsonFt dequeueSmallJson;\ 2975 dequeueSmallStringSmallJsonFt dequeueSmallString;\ 2976 dequeueVoidSmallJsonFt dequeueVoid;\ 2977 dequeueSmallContainerSmallJsonFt dequeueSmallContainer;\ 2978 dequeueNumSmallJsonFt dequeueNum;\ 2979 reverseSmallJsonFt reverse;\ 2980 catSmallJsonFt cat;\ 2981 mergeDictSmallJsonFt mergeDict;\ 2982 mergeDictNSmashSmallJsonFt mergeDictNSmash;\ 2983 mergeSmallJsonFt merge;\ 2984 mergeNSmashSmallJsonFt mergeNSmash;\ 2985 appendSmallJsonFt append;\ 2986 appendNSmashSmallJsonFt appendNSmash;\ 2987 appendArraySmallJsonFt appendArray;\ 2988 appendCArraySmallJsonFt appendCArray;\ 2989 appendNSmashArraySmallJsonFt appendNSmashArray;\ 2990 shiftSmallJsonFt shift;\ 2991 shiftNSmashSmallJsonFt shiftNSmash;\ 2992 shiftSmallJsonSmallJsonFt shiftSmallJson;\ 2993 shiftNSmashSmallJsonSmallJsonFt shiftNSmashSmallJson;\ 2994 addSmallJsonFt add;\ 2995 addJsonSmallJsonFt addJson;\ 2996 sliceSmallJsonFt slice;\ 2997 cropSmallJsonFt crop;\ 2998 cropSSmallJsonFt cropS;\ 2999 cropSmallStringSmallJsonFt cropSmallString;\ 3000 cropElemAtSmallJsonFt cropElemAt;\ 3001 cropElemAtUndefinedSmallJsonFt cropElemAtUndefined;\ 3002 cropElemAtBoolSmallJsonFt cropElemAtBool;\ 3003 cropElemAtDoubleSmallJsonFt cropElemAtDouble;\ 3004 cropElemAtIntSmallJsonFt cropElemAtInt;\ 3005 cropElemAtInt32SmallJsonFt cropElemAtInt32;\ 3006 cropElemAtUintSmallJsonFt cropElemAtUint;\ 3007 cropElemAtUint32SmallJsonFt cropElemAtUint32;\ 3008 cropElemAtSSmallJsonFt cropElemAtS;\ 3009 cropElemAtCharSmallJsonFt cropElemAtChar;\ 3010 cropElemAtDictSmallJsonFt cropElemAtDict;\ 3011 cropElemAtArraySmallJsonFt cropElemAtArray;\ 3012 cropElemAtSmallBoolSmallJsonFt cropElemAtSmallBool;\ 3013 cropElemAtSmallBytesSmallJsonFt cropElemAtSmallBytes;\ 3014 cropElemAtSmallDoubleSmallJsonFt cropElemAtSmallDouble;\ 3015 cropElemAtSmallIntSmallJsonFt cropElemAtSmallInt;\ 3016 cropElemAtSmallJsonSmallJsonFt cropElemAtSmallJson;\ 3017 cropElemAtSmallStringSmallJsonFt cropElemAtSmallString;\ 3018 cropElemAtVoidSmallJsonFt cropElemAtVoid;\ 3019 cropElemAtSmallContainerSmallJsonFt cropElemAtSmallContainer;\ 3020 cropElemKeySmallJsonFt cropElemKey;\ 3021 cropElemKeyUndefinedSmallJsonFt cropElemKeyUndefined;\ 3022 cropElemKeyBoolSmallJsonFt cropElemKeyBool;\ 3023 cropElemKeyDoubleSmallJsonFt cropElemKeyDouble;\ 3024 cropElemKeyIntSmallJsonFt cropElemKeyInt;\ 3025 cropElemKeyInt32SmallJsonFt cropElemKeyInt32;\ 3026 cropElemKeyUintSmallJsonFt cropElemKeyUint;\ 3027 cropElemKeyUint32SmallJsonFt cropElemKeyUint32;\ 3028 cropElemKeySSmallJsonFt cropElemKeyS;\ 3029 cropElemKeyDictSmallJsonFt cropElemKeyDict;\ 3030 cropElemKeyArraySmallJsonFt cropElemKeyArray;\ 3031 cropElemKeySmallBoolSmallJsonFt cropElemKeySmallBool;\ 3032 cropElemKeySmallBytesSmallJsonFt cropElemKeySmallBytes;\ 3033 cropElemKeySmallDoubleSmallJsonFt cropElemKeySmallDouble;\ 3034 cropElemKeySmallIntSmallJsonFt cropElemKeySmallInt;\ 3035 cropElemKeySmallJsonSmallJsonFt cropElemKeySmallJson;\ 3036 cropElemKeySmallStringSmallJsonFt cropElemKeySmallString;\ 3037 cropElemKeyVoidSmallJsonFt cropElemKeyVoid;\ 3038 cropElemKeySmallContainerSmallJsonFt cropElemKeySmallContainer;\ 3039 copySmallJsonFt copy;\ 3040 insertSmallJsonFt insert;\ 3041 insertNSmashSmallJsonFt insertNSmash;\ 3042 insertSmallJsonSmallJsonFt insertSmallJson;\ 3043 insertNSmashSmallJsonSmallJsonFt insertNSmashSmallJson;\ 3044 insertStringSmallJsonFt insertString;\ 3045 insertSSmallJsonFt insertS;\ 3046 insertNFreeStringSmallJsonFt insertNFreeString;\ 3047 insertSNFreeSmallJsonFt insertSNFree;\ 3048 injectSmallJsonFt inject;\ 3049 injectUndefinedSmallJsonFt injectUndefined;\ 3050 injectBoolSmallJsonFt injectBool;\ 3051 injectDoubleSmallJsonFt injectDouble;\ 3052 injectIntSmallJsonFt injectInt;\ 3053 injectSSmallJsonFt injectS;\ 3054 injectCharSmallJsonFt injectChar;\ 3055 injectDictSmallJsonFt injectDict;\ 3056 injectArraySmallJsonFt injectArray;\ 3057 injectArraycSmallJsonFt injectArrayc;\ 3058 injectCArraycSmallJsonFt injectCArrayc;\ 3059 injectSmallBoolSmallJsonFt injectSmallBool;\ 3060 injectSmallBytesSmallJsonFt injectSmallBytes;\ 3061 injectSmallDoubleSmallJsonFt injectSmallDouble;\ 3062 injectSmallIntSmallJsonFt injectSmallInt;\ 3063 injectSmallJsonSmallJsonFt injectSmallJson;\ 3064 injectSmallStringSmallJsonFt injectSmallString;\ 3065 injectSmallContainerSmallJsonFt injectSmallContainer;\ 3066 injectNFreeSmallJsonFt injectNFree;\ 3067 injectNFreeUndefinedSmallJsonFt injectNFreeUndefined;\ 3068 injectNFreeSSmallJsonFt injectNFreeS;\ 3069 injectNFreeDictSmallJsonFt injectNFreeDict;\ 3070 injectNFreeArraySmallJsonFt injectNFreeArray;\ 3071 injectNFreeArraycSmallJsonFt injectNFreeArrayc;\ 3072 injectNFreeSmallBoolSmallJsonFt injectNFreeSmallBool;\ 3073 injectNFreeSmallBytesSmallJsonFt injectNFreeSmallBytes;\ 3074 injectNFreeSmallDoubleSmallJsonFt injectNFreeSmallDouble;\ 3075 injectNFreeSmallIntSmallJsonFt injectNFreeSmallInt;\ 3076 injectNFreeSmallJsonSmallJsonFt injectNFreeSmallJson;\ 3077 injectNFreeSmallStringSmallJsonFt injectNFreeSmallString;\ 3078 injectNFreeSmallContainerSmallJsonFt injectNFreeSmallContainer;\ 3079 uniqSmallJsonFt uniq;\ 3080 icUniqSmallJsonFt icUniq;\ 3081 uniqCharSmallJsonFt uniqChar;\ 3082 icUniqCharSmallJsonFt icUniqChar;\ 3083 sortSmallJsonFt sort;\ 3084 sortFSmallJsonFt sortF;\ 3085 icSortSmallJsonFt icSort;\ 3086 hasSmallJsonFt has;\ 3087 hasUndefinedSmallJsonFt hasUndefined;\ 3088 hasBoolSmallJsonFt hasBool;\ 3089 hasDoubleSmallJsonFt hasDouble;\ 3090 hasIntSmallJsonFt hasInt;\ 3091 hasSSmallJsonFt hasS;\ 3092 hasCharSmallJsonFt hasChar;\ 3093 hasDictSmallJsonFt hasDict;\ 3094 hasArraySmallJsonFt hasArray;\ 3095 hasArraycSmallJsonFt hasArrayc;\ 3096 hasCArraycSmallJsonFt hasCArrayc;\ 3097 hasSmallBoolSmallJsonFt hasSmallBool;\ 3098 hasSmallBytesSmallJsonFt hasSmallBytes;\ 3099 hasSmallDoubleSmallJsonFt hasSmallDouble;\ 3100 hasSmallIntSmallJsonFt hasSmallInt;\ 3101 hasSmallJsonSmallJsonFt hasSmallJson;\ 3102 hasSmallStringSmallJsonFt hasSmallString;\ 3103 hasSmallContainerSmallJsonFt hasSmallContainer;\ 3104 findSmallJsonFt find;\ 3105 findCharSmallJsonFt findChar;\ 3106 findSmallStringSmallJsonFt findSmallString;\ 3107 findJsonSmallJsonFt findJson;\ 3108 indexOfSmallJsonFt indexOf;\ 3109 indexOfUndefinedSmallJsonFt indexOfUndefined;\ 3110 indexOfBoolSmallJsonFt indexOfBool;\ 3111 indexOfDoubleSmallJsonFt indexOfDouble;\ 3112 indexOfIntSmallJsonFt indexOfInt;\ 3113 indexOfSSmallJsonFt indexOfS;\ 3114 indexOfCharSmallJsonFt indexOfChar;\ 3115 indexOfDictSmallJsonFt indexOfDict;\ 3116 indexOfArraySmallJsonFt indexOfArray;\ 3117 indexOfArraycSmallJsonFt indexOfArrayc;\ 3118 indexOfCArraycSmallJsonFt indexOfCArrayc;\ 3119 indexOfSmallBoolSmallJsonFt indexOfSmallBool;\ 3120 indexOfSmallBytesSmallJsonFt indexOfSmallBytes;\ 3121 indexOfSmallDoubleSmallJsonFt indexOfSmallDouble;\ 3122 indexOfSmallIntSmallJsonFt indexOfSmallInt;\ 3123 indexOfSmallJsonSmallJsonFt indexOfSmallJson;\ 3124 indexOfSmallStringSmallJsonFt indexOfSmallString;\ 3125 indexOfSmallContainerSmallJsonFt indexOfSmallContainer;\ 3126 binarySearchSmallJsonFt binarySearch;\ 3127 binarySearchUndefinedSmallJsonFt binarySearchUndefined;\ 3128 binarySearchBoolSmallJsonFt binarySearchBool;\ 3129 binarySearchDoubleSmallJsonFt binarySearchDouble;\ 3130 binarySearchIntSmallJsonFt binarySearchInt;\ 3131 binarySearchSSmallJsonFt binarySearchS;\ 3132 binarySearchCharSmallJsonFt binarySearchChar;\ 3133 binarySearchDictSmallJsonFt binarySearchDict;\ 3134 binarySearchArraySmallJsonFt binarySearchArray;\ 3135 binarySearchArraycSmallJsonFt binarySearchArrayc;\ 3136 binarySearchCArraycSmallJsonFt binarySearchCArrayc;\ 3137 binarySearchSmallBoolSmallJsonFt binarySearchSmallBool;\ 3138 binarySearchSmallBytesSmallJsonFt binarySearchSmallBytes;\ 3139 binarySearchSmallDoubleSmallJsonFt binarySearchSmallDouble;\ 3140 binarySearchSmallIntSmallJsonFt binarySearchSmallInt;\ 3141 binarySearchSmallJsonSmallJsonFt binarySearchSmallJson;\ 3142 binarySearchSmallStringSmallJsonFt binarySearchSmallString;\ 3143 binarySearchSmallContainerSmallJsonFt binarySearchSmallContainer;\ 3144 icHasSmallJsonFt icHas;\ 3145 icHasSSmallJsonFt icHasS;\ 3146 icHasCharSmallJsonFt icHasChar;\ 3147 icHasDictSmallJsonFt icHasDict;\ 3148 icHasArraySmallJsonFt icHasArray;\ 3149 icHasArraycSmallJsonFt icHasArrayc;\ 3150 icHasCArraycSmallJsonFt icHasCArrayc;\ 3151 icHasSmallStringSmallJsonFt icHasSmallString;\ 3152 icFindSmallJsonFt icFind;\ 3153 icFindCharSmallJsonFt icFindChar;\ 3154 icFindSmallStringSmallJsonFt icFindSmallString;\ 3155 icFindJsonSmallJsonFt icFindJson;\ 3156 icIndexOfSmallJsonFt icIndexOf;\ 3157 icIndexOfSSmallJsonFt icIndexOfS;\ 3158 icIndexOfCharSmallJsonFt icIndexOfChar;\ 3159 icIndexOfDictSmallJsonFt icIndexOfDict;\ 3160 icIndexOfArraySmallJsonFt icIndexOfArray;\ 3161 icIndexOfArraycSmallJsonFt icIndexOfArrayc;\ 3162 icIndexOfCArraycSmallJsonFt icIndexOfCArrayc;\ 3163 icIndexOfSmallStringSmallJsonFt icIndexOfSmallString;\ 3164 icBinarySearchSmallJsonFt icBinarySearch;\ 3165 icBinarySearchSSmallJsonFt icBinarySearchS;\ 3166 icBinarySearchCharSmallJsonFt icBinarySearchChar;\ 3167 icBinarySearchDictSmallJsonFt icBinarySearchDict;\ 3168 icBinarySearchArraySmallJsonFt icBinarySearchArray;\ 3169 icBinarySearchArraycSmallJsonFt icBinarySearchArrayc;\ 3170 icBinarySearchCArraycSmallJsonFt icBinarySearchCArrayc;\ 3171 icBinarySearchSmallStringSmallJsonFt icBinarySearchSmallString;\ 3172 keyBySmallJsonFt keyBy;\ 3173 keyByUndefinedSmallJsonFt keyByUndefined;\ 3174 keyByBoolSmallJsonFt keyByBool;\ 3175 keyByDoubleSmallJsonFt keyByDouble;\ 3176 keyByIntSmallJsonFt keyByInt;\ 3177 keyBySSmallJsonFt keyByS;\ 3178 keyByCharSmallJsonFt keyByChar;\ 3179 keyByDictSmallJsonFt keyByDict;\ 3180 keyByArraySmallJsonFt keyByArray;\ 3181 keyByArraycSmallJsonFt keyByArrayc;\ 3182 keyByCArraycSmallJsonFt keyByCArrayc;\ 3183 keyBySmallBoolSmallJsonFt keyBySmallBool;\ 3184 keyBySmallBytesSmallJsonFt keyBySmallBytes;\ 3185 keyBySmallDoubleSmallJsonFt keyBySmallDouble;\ 3186 keyBySmallIntSmallJsonFt keyBySmallInt;\ 3187 keyBySmallJsonSmallJsonFt keyBySmallJson;\ 3188 keyBySmallStringSmallJsonFt keyBySmallString;\ 3189 keyBySmallContainerSmallJsonFt keyBySmallContainer;\ 3190 icKeyBySmallJsonFt icKeyBy;\ 3191 icKeyBySSmallJsonFt icKeyByS;\ 3192 icKeyByCharSmallJsonFt icKeyByChar;\ 3193 icKeyByDictSmallJsonFt icKeyByDict;\ 3194 icKeyByArraySmallJsonFt icKeyByArray;\ 3195 icKeyByArraycSmallJsonFt icKeyByArrayc;\ 3196 icKeyByCArraycSmallJsonFt icKeyByCArrayc;\ 3197 icKeyBySmallStringSmallJsonFt icKeyBySmallString;\ 3198 replaceSmallJsonFt replace;\ 3199 replaceCharSSmallJsonFt replaceCharS;\ 3200 replaceSCharSmallJsonFt replaceSChar;\ 3201 replaceCharCharSmallJsonFt replaceCharChar;\ 3202 replaceSmallStringSmallStringSmallJsonFt replaceSmallStringSmallString;\ 3203 replaceSmallStringSSmallJsonFt replaceSmallStringS;\ 3204 replaceSmallStringCharSmallJsonFt replaceSmallStringChar;\ 3205 replaceSSmallStringSmallJsonFt replaceSSmallString;\ 3206 replaceCharSmallStringSmallJsonFt replaceCharSmallString;\ 3207 replaceJsonJsonSmallJsonFt replaceJsonJson;\ 3208 replaceJsonSmallStringSmallJsonFt replaceJsonSmallString;\ 3209 replaceJsonSSmallJsonFt replaceJsonS;\ 3210 replaceJsonCharSmallJsonFt replaceJsonChar;\ 3211 replaceSmallStringJsonSmallJsonFt replaceSmallStringJson;\ 3212 replaceSJsonSmallJsonFt replaceSJson;\ 3213 replaceCharJsonSmallJsonFt replaceCharJson;\ 3214 replaceManySmallJsonFt replaceMany;\ 3215 icReplaceSmallJsonFt icReplace;\ 3216 icReplaceCharSSmallJsonFt icReplaceCharS;\ 3217 icReplaceSCharSmallJsonFt icReplaceSChar;\ 3218 icReplaceCharCharSmallJsonFt icReplaceCharChar;\ 3219 icReplaceSmallStringSmallStringSmallJsonFt icReplaceSmallStringSmallString;\ 3220 icReplaceSmallStringSSmallJsonFt icReplaceSmallStringS;\ 3221 icReplaceSmallStringCharSmallJsonFt icReplaceSmallStringChar;\ 3222 icReplaceSSmallStringSmallJsonFt icReplaceSSmallString;\ 3223 icReplaceCharSmallStringSmallJsonFt icReplaceCharSmallString;\ 3224 icReplaceJsonJsonSmallJsonFt icReplaceJsonJson;\ 3225 icReplaceJsonSmallStringSmallJsonFt icReplaceJsonSmallString;\ 3226 icReplaceJsonSSmallJsonFt icReplaceJsonS;\ 3227 icReplaceJsonCharSmallJsonFt icReplaceJsonChar;\ 3228 icReplaceSmallStringJsonSmallJsonFt icReplaceSmallStringJson;\ 3229 icReplaceSJsonSmallJsonFt icReplaceSJson;\ 3230 icReplaceCharJsonSmallJsonFt icReplaceCharJson;\ 3231 icReplaceManySmallJsonFt icReplaceMany;\ 3232 equalSmallJsonSmallArrayFt equalSmallArray;\ 3233 equalSmallJsonArrayFt equalArray;\ 3234 equalSmallJsonCArrayFt equalCArray;\ 3235 equalSmallJsonBaseFt equalBase;\ 3236 equalSmallJsonChaFt equalCha;\ 3237 equalSmallJsonCharFt equalChar;\ 3238 equalSmallJsonBoolFt equalBool;\ 3239 equalSmallJsonDoubleFt equalDouble;\ 3240 equalSmallJsonInt64Ft equalInt64;\ 3241 equalSmallJsonInt32Ft equalInt32;\ 3242 equalSmallJsonUint32Ft equalUint32;\ 3243 equalSmallJsonUint64Ft equalUint64;\ 3244 equalSmallJsonSmallBoolFt equalSmallBool;\ 3245 equalSmallJsonSmallBytesFt equalSmallBytes;\ 3246 equalSmallJsonSmallDoubleFt equalSmallDouble;\ 3247 equalSmallJsonSmallIntFt equalSmallInt;\ 3248 equalSmallJsonSmallJsonFt equalSmallJson;\ 3249 equalSmallJsonSmallStringFt equalSmallString;\ 3250 equalSmallJsonSmallDictFt equalSmallDict;\ 3251 icEqualSmallJsonSmallArrayFt icEqualSmallArray;\ 3252 icEqualSmallJsonArrayFt icEqualArray;\ 3253 icEqualSmallJsonCArrayFt icEqualCArray;\ 3254 icEqualSmallJsonBaseFt icEqualBase;\ 3255 icEqualSmallJsonSmallDictFt icEqualSmallDict;\ 3256 icEqualSmallJsonSmallJsonFt icEqualSmallJson;\ 3257 icEqualSmallJsonSmallStringFt icEqualSmallString;\ 3258 icEqualSSmallJsonFt icEqualS;\ 3259 icEqualCharSmallJsonFt icEqualChar;\ 3260 equalISSmallJsonFt equalIS;\ 3261 equalICharSmallJsonFt equalIChar;\ 3262 equalIJsonSmallJsonFt equalIJson;\ 3263 equalISmallStringSmallJsonFt equalISmallString;\ 3264 startsWithSSmallJsonFt startsWithS;\ 3265 startsWithCharSmallJsonFt startsWithChar;\ 3266 startsWithSmallStringSmallJsonFt startsWithSmallString;\ 3267 startsWithJsonSmallJsonFt startsWithJson;\ 3268 endsWithSSmallJsonFt endsWithS;\ 3269 endsWithCharSmallJsonFt endsWithChar;\ 3270 endsWithSmallStringSmallJsonFt endsWithSmallString;\ 3271 endsWithJsonSmallJsonFt endsWithJson;\ 3272 countSSmallJsonFt countS;\ 3273 countCharSmallJsonFt countChar;\ 3274 countSmallStringSmallJsonFt countSmallString;\ 3275 countJsonSmallJsonFt countJson;\ 3276 icStartsWithSSmallJsonFt icStartsWithS;\ 3277 icStartsWithCharSmallJsonFt icStartsWithChar;\ 3278 icStartsWithSmallStringSmallJsonFt icStartsWithSmallString;\ 3279 icStartsWithJsonSmallJsonFt icStartsWithJson;\ 3280 icEndsWithSSmallJsonFt icEndsWithS;\ 3281 icEndsWithCharSmallJsonFt icEndsWithChar;\ 3282 icEndsWithSmallStringSmallJsonFt icEndsWithSmallString;\ 3283 icEndsWithJsonSmallJsonFt icEndsWithJson;\ 3284 icCountSSmallJsonFt icCountS;\ 3285 icCountCharSmallJsonFt icCountChar;\ 3286 icCountSmallStringSmallJsonFt icCountSmallString;\ 3287 icCountJsonSmallJsonFt icCountJson;\ 3288 isNumberSmallJsonFt isNumber;\ 3289 isIntSmallJsonFt isInt;\ 3290 parseIntSmallJsonFt parseInt;\ 3291 parseDoubleSmallJsonFt parseDouble;\ 3292 intToSmallJsonFt intTo;\ 3293 doubleToSmallJsonFt doubleTo;\ 3294 lenSmallJsonFt len;\ 3295 upperSmallJsonFt upper;\ 3296 lowerSmallJsonFt lower;\ 3297 trimSmallJsonFt trim;\ 3298 lTrimSmallJsonFt lTrim;\ 3299 rTrimSmallJsonFt rTrim;\ 3300 keysSmallJsonFt keys;\ 3301 keysSmallStringSmallJsonFt keysSmallString;\ 3302 valuesSmallJsonFt values;\ 3303 compactSmallJsonFt compact;\ 3304 emptySmallJsonFt empty;\ 3305 isEmptySmallJsonFt isEmpty;\ 3306 isBlankSmallJsonFt isBlank;\ 3307 forEachSmallJsonFt forEach;\ 3308 enumerateSmallJsonFt enumerate;\ 3309 enumerateDictSmallJsonFt enumerateDict;\ 3310 joinSmallJsonFt join;\ 3311 joinCharSmallJsonFt joinChar;\ 3312 joinSmallJsonSmallJsonFt joinSmallJson;\ 3313 joinSmallStringSmallJsonFt joinSmallString;\ 3314 joinSSmallJsonFt joinS;\ 3315 joinCharSSmallJsonFt joinCharS;\ 3316 joinSmallJsonSSmallJsonFt joinSmallJsonS;\ 3317 joinSmallStringSSmallJsonFt joinSmallStringS;\ 3318 splitSmallJsonFt split;\ 3319 splitCharSmallJsonFt splitChar;\ 3320 splitSmallJsonSmallJsonFt splitSmallJson;\ 3321 splitSmallStringSmallJsonFt splitSmallString;\ 3322 splitSSmallJsonFt splitS;\ 3323 splitCharSSmallJsonFt splitCharS;\ 3324 splitSmallJsonSSmallJsonFt splitSmallJsonS;\ 3325 splitSmallStringSSmallJsonFt splitSmallStringS;\ 3326 extractSmallJsonFt extract;\ 3327 extractCharSSmallJsonFt extractCharS;\ 3328 extractSCharSmallJsonFt extractSChar;\ 3329 extractCharCharSmallJsonFt extractCharChar;\ 3330 extractSmallJsonSmallJsonSmallJsonFt extractSmallJsonSmallJson;\ 3331 extractSmallJsonSmallStringSmallJsonFt extractSmallJsonSmallString;\ 3332 extractSmallJsonSSmallJsonFt extractSmallJsonS;\ 3333 extractSmallJsonCharSmallJsonFt extractSmallJsonChar;\ 3334 extractSmallStringSmallJsonSmallJsonFt extractSmallStringSmallJson;\ 3335 extractSmallStringSmallStringSmallJsonFt extractSmallStringSmallString;\ 3336 extractSmallStringSSmallJsonFt extractSmallStringS;\ 3337 extractSmallStringCharSmallJsonFt extractSmallStringChar;\ 3338 extractSSmallJsonSmallJsonFt extractSSmallJson;\ 3339 extractSSmallStringSmallJsonFt extractSSmallString;\ 3340 extractCharSmallJsonSmallJsonFt extractCharSmallJson;\ 3341 extractCharSmallStringSmallJsonFt extractCharSmallString;\ 3342 icSplitSmallJsonFt icSplit;\ 3343 icSplitCharSmallJsonFt icSplitChar;\ 3344 icSplitSmallJsonSmallJsonFt icSplitSmallJson;\ 3345 icSplitSmallStringSmallJsonFt icSplitSmallString;\ 3346 icSplitSSmallJsonFt icSplitS;\ 3347 icSplitCharSSmallJsonFt icSplitCharS;\ 3348 icSplitSmallJsonSSmallJsonFt icSplitSmallJsonS;\ 3349 icSplitSmallStringSSmallJsonFt icSplitSmallStringS;\ 3350 icExtractSmallJsonFt icExtract;\ 3351 icExtractCharSSmallJsonFt icExtractCharS;\ 3352 icExtractSCharSmallJsonFt icExtractSChar;\ 3353 icExtractCharCharSmallJsonFt icExtractCharChar;\ 3354 icExtractSmallJsonSmallJsonSmallJsonFt icExtractSmallJsonSmallJson;\ 3355 icExtractSmallJsonSmallStringSmallJsonFt icExtractSmallJsonSmallString;\ 3356 icExtractSmallJsonSSmallJsonFt icExtractSmallJsonS;\ 3357 icExtractSmallJsonCharSmallJsonFt icExtractSmallJsonChar;\ 3358 icExtractSmallStringSmallJsonSmallJsonFt icExtractSmallStringSmallJson;\ 3359 icExtractSmallStringSmallStringSmallJsonFt icExtractSmallStringSmallString;\ 3360 icExtractSmallStringSSmallJsonFt icExtractSmallStringS;\ 3361 icExtractSmallStringCharSmallJsonFt icExtractSmallStringChar;\ 3362 icExtractSSmallJsonSmallJsonFt icExtractSSmallJson;\ 3363 icExtractSSmallStringSmallJsonFt icExtractSSmallString;\ 3364 icExtractCharSmallJsonSmallJsonFt icExtractCharSmallJson;\ 3365 icExtractCharSmallStringSmallJsonFt icExtractCharSmallString;\ 3366 colorSmallJsonFt color;\ 3367 colordSmallJsonFt colord;\ 3368 zipSmallJsonFt zip;\ 3369 zipArraySmallJsonFt zipArray;\ 3370 zipCArraySmallJsonFt zipCArray;\ 3371 zipCharSmallJsonFt zipChar;\ 3372 zipCCharSmallJsonFt zipCChar;\ 3373 zipArrayCharSmallJsonFt zipArrayChar;\ 3374 zipCArrayCharSmallJsonFt zipCArrayChar;\ 3375 zipArrayCCharSmallJsonFt zipArrayCChar;\ 3376 zipCArrayCCharSmallJsonFt zipCArrayCChar;\ 3377 zipJsonSmallJsonFt zipJson;\ 3378 zipJsonSmallArraySmallJsonFt zipJsonSmallArray;\ 3379 zipJsonArraySmallJsonFt zipJsonArray;\ 3380 zipJsonCArraySmallJsonFt zipJsonCArray;\ 3381 zipSmallArrayJsonSmallJsonFt zipSmallArrayJson;\ 3382 zipArrayJsonSmallJsonFt zipArrayJson;\ 3383 zipCArrayJsonSmallJsonFt zipCArrayJson;\ 3384 iterStartSmallJsonFt iterStart;\ 3385 iterStartKeySmallJsonFt iterStartKey;\ 3386 iterStartLastSmallJsonFt iterStartLast;\ 3387 iterStartFromSmallJsonFt iterStartFrom;\ 3388 iterStartFromStepSmallJsonFt iterStartFromStep;\ 3389 iterNextSmallJsonFt iterNext;\ 3390 iterNextKeySmallJsonFt iterNextKey;\ 3391 iterElementSmallJsonFt iterElement;\ 3392 iterKeySmallJsonFt iterKey;\ 3393 iterIndexSmallJsonFt iterIndex;\ 3394 iterStepSmallJsonFt iterStep;\ 3395 stringifySmallJsonFt stringify;\ 3396 stringifySmallStringSmallJsonFt stringifySmallString;\ 3397 toYMLSmallJsonFt toYML;\ 3398 toYMLSmallStringSmallJsonFt toYMLSmallString;\ 3399 parseSmallJsonFt parse;\ 3400 parseSmallJsonSmallJsonFt parseSmallJson; \ 3401 parseSmallStringSmallJsonFt parseSmallString; \ 3402 parseYMLSmallJsonFt parseYML;\ 3403 parseYMLSmallJsonSmallJsonFt parseYMLSmallJson;\ 3404 parseYMLSmallStringSmallJsonFt parseYMLSmallString;\ 3405 serialSmallJsonFt serial;\ 3406 deserialSmallJsonFt deserial;\ 3407 logSmallJsonFt log;\ 3408 readFileSmallJsonFt readFile;\ 3409 readFileSmallStringSmallJsonFt readFileSmallString;\ 3410 readFileJsonSmallJsonFt readFileJson;\ 3411 readStreamSmallJsonFt readStream;\ 3412 writeFileSmallJsonFt writeFile;\ 3413 writeFileSmallStringSmallJsonFt writeFileSmallString;\ 3414 writeFileJsonSmallJsonFt writeFileJson;\ 3415 writeStreamSmallJsonFt writeStream;\ 3416 appendFileSmallJsonFt appendFile;\ 3417 appendFileSmallStringSmallJsonFt appendFileSmallString;\ 3418 appendFileJsonSmallJsonFt appendFileJson;\ 3419 readTextSmallJsonFt readText;\ 3420 readTextSmallStringSmallJsonFt readTextSmallString;\ 3421 readTextJsonSmallJsonFt readTextJson;\ 3422 readTextStreamSmallJsonFt readTextStream;\ 3423 writeTextSmallJsonFt writeText;\ 3424 writeTextSmallStringSmallJsonFt writeTextSmallString;\ 3425 writeTextJsonSmallJsonFt writeTextJson;\ 3426 writeTextStreamSmallJsonFt writeTextStream;\ 3427 appendTextSmallJsonFt appendText;\ 3428 appendTextSmallStringSmallJsonFt appendTextSmallString;\ 3429 appendTextJsonSmallJsonFt appendTextJson;\ 3430 typeStringSmallJsonFt typeString;\ 3431 typeSmallStringSmallJsonFt typeSmallString;\ 3432 typeAtStringSmallJsonFt typeAtString;\ 3433 typeAtSmallStringSmallJsonFt typeAtSmallString;\ 3434 typeStringKCharSmallJsonFt typeStringKChar;\ 3435 typeSmallStringKCharSmallJsonFt typeSmallStringKChar;\ 3436 typeSmallJsonFt type;\ 3437 typeKCharSmallJsonFt typeKChar;\ 3438 typeAtSmallJsonFt typeAt;\ 3439 typeStringsSmallJsonFt typeStrings;\ 3440 typesSmallJsonFt types;\ 3441 isETypeAtSmallJsonFt isETypeAt;\ 3442 isEUndefinedAtSmallJsonFt isEUndefinedAt;\ 3443 isEBoolAtSmallJsonFt isEBoolAt;\ 3444 isEContainerAtSmallJsonFt isEContainerAt;\ 3445 isEDictAtSmallJsonFt isEDictAt;\ 3446 isEDoubleAtSmallJsonFt isEDoubleAt;\ 3447 isEIntAtSmallJsonFt isEIntAt;\ 3448 isEStringAtSmallJsonFt isEStringAt;\ 3449 isEFaststringAtSmallJsonFt isEFaststringAt;\ 3450 isEArrayAtSmallJsonFt isEArrayAt;\ 3451 isEBytesAtSmallJsonFt isEBytesAt;\ 3452 isETypeSmallJsonFt isEType;\ 3453 isEUndefinedSmallJsonFt isEUndefined;\ 3454 isEBoolSmallJsonFt isEBool;\ 3455 isEContainerSmallJsonFt isEContainer;\ 3456 isEDictSmallJsonFt isEDict;\ 3457 isEDoubleSmallJsonFt isEDouble;\ 3458 isEIntSmallJsonFt isEInt;\ 3459 isEStringSmallJsonFt isEString;\ 3460 isEFaststringSmallJsonFt isEFaststring;\ 3461 isEArraySmallJsonFt isEArray;\ 3462 isEBytesSmallJsonFt isEBytes;\ 3463 areAllETypeSmallJsonFt areAllEType;\ 3464 areAllEUndefinedSmallJsonFt areAllEUndefined;\ 3465 areAllEBoolSmallJsonFt areAllEBool;\ 3466 areAllEContainerSmallJsonFt areAllEContainer;\ 3467 areAllEDictSmallJsonFt areAllEDict;\ 3468 areAllEDoubleSmallJsonFt areAllEDouble;\ 3469 areAllEIntSmallJsonFt areAllEInt;\ 3470 areAllEStringSmallJsonFt areAllEString;\ 3471 areAllEFaststringSmallJsonFt areAllEFaststring;\ 3472 areAllEArraySmallJsonFt areAllEArray;\ 3473 areAllEBytesSmallJsonFt areAllEBytes 3474 3475 3476 typedef struct { 3477 freeSmallJsonFt free; 3478 terminateSmallJsonFt terminate; 3479 toStringSmallJsonFt toString; 3480 duplicateSmallJsonFt duplicate; 3481 smashSmallJsonFt smash; 3482 finishSmallJsonFt finish; 3483 SMALLJSONFUNCTIONST; 3484 } smallJsonFunctionst; 3485 3486 /** 3487 * class 3488 */ 3489 struct smallJson { 3490 const char *type; 3491 smallJsonFunctionst *f; 3492 3493 // private 3494 int topIsA; 3495 sUndefinedt *topU; 3496 sBoolt *topB; 3497 sDoublet *topD; 3498 sIntt *topI; 3499 sStringt *topS; 3500 sDictt *top; 3501 sArrayt *topA; 3502 3503 int iProp; 3504 sArrayt *parseP; 3505 int istack; 3506 // iterElementDataType indicates what the type baset object in iterElement 3507 // if iterElement is not small* class object then finish must not be called 3508 // in the iterator 3509 // baset objects not from small* classes are stored directly in smallContainers 3510 // values: SH_DT_UNKNOWN, SH_DT_BASET 3511 char iterElementDataType; 3512 sArrayt *stack; 3513 void **propertyOrValue; 3514 ssize_t iterIndex; 3515 char* iterKey; 3516 int64_t iterStep; 3517 baset* iterElement; 3518 }; 3519 3520 // base 3521 3522 #define createSmallJson(obj) ;smallJsont obj; initiateSmallJson(&obj) 3523 #define createAllocateSmallJson(obj) ;smallJsont *obj; initiateAllocateSmallJson(&obj) 3524 3525 void initiateSmallJson(smallJsont *self); 3526 void initiateAllocateSmallJson(smallJsont **self); 3527 void finalizeRecycleSmallJson(void *arg UNUSED); 3528 void finalizeSmallJson(void); 3529 3530 // initialize class methods, call registerMethodsSmallJson from classes inheriting this class 3531 void registerMethodsSmallJson(smallJsonFunctionst *f); 3532 3533 smallJsont* allocSmallJson(void); 3534 3535 /** 3536 * create String Array Function 3537 * 3538 * create a smallJson for list of strings 3539 * 3540 * \return 3541 * smallJson 3542 */ 3543 smallJsont* createSJF(const char *paramType, ...); 3544 #define createSJ(...) createSJF("", __VA_ARGS__, NULL) 3545 3546 smallJsont* allocSmallJsonG(smallJsont *self UNUSED); 3547 3548 // terminate smallJsont val when it is out of scope 3549 void cleanUpSmallJsonTerminateG(smallJsont **val); 3550 3551 // free smallJsont local val when it is out of scope 3552 void cleanUpSmallJsonFreeLocalG(smallJsont *val); 3553 3554 // free smallJsont val when it is out of scope 3555 void cleanUpSmallJsonFreeG(smallJsont **val); 3556 3557 // finish smallJsont val when it is out of scope 3558 void cleanUpSmallJsonFinishG(smallJsont **val); 3559 3560 // dispose smallJsont val when it is out of scope 3561 void cleanUpSmallJsonDisposeG(smallJsont *val); 3562 3563 // smash smallJsont val when it is out of scope 3564 void cleanUpSmallJsonSmashG(smallJsont **val); 3565 3566 /** 3567 * declare pointer name with type smallJsont and terminate name when it is out of scope 3568 */ 3569 #define cleanSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonTerminateG) 3570 3571 /** 3572 * allocate smallJson (pointer) and clean up when it is out of scope 3573 */ 3574 #define cleanAllocateSmallJson(obj) ;cleanSmallJsonP(obj); initiateAllocateSmallJson(&obj) 3575 3576 /** 3577 * declare local object name with Type smallJsont and free name when it is out of scope 3578 */ 3579 #define cleanSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonFreeLocalG); initiateSmallJson(&name) 3580 3581 /** 3582 * declare pointer name with type smallJsont and free name when it is out of scope 3583 */ 3584 #define cleanFreeSmallJson(name) smallJsont *name CLEANUP(cleanUpSmallJsonFreeG) 3585 3586 /** 3587 * declare pointer name with Type smallJsont and finish name when it is out of scope 3588 */ 3589 #define cleanFinishSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonFinishG) 3590 3591 /** 3592 * declare local object name with Type smallJsont and dispose name when it is out of scope 3593 */ 3594 #define cleanDisposeSmallJson(name) smallJsont name CLEANUP(cleanUpSmallJsonDisposeG); initiateSmallJson(&name) 3595 3596 /** 3597 * declare pointer name with Type smallJsont and smash name when it is out of scope 3598 */ 3599 #define cleanSmashSmallJsonP(name) smallJsont *name CLEANUP(cleanUpSmallJsonSmashG) 3600 3601 smallJsont* duplicateSmallJsonG (smallJsont *self); 3602 3603 void freeSmallJsonG (smallJsont *self); 3604 3605 smallJsont* setTopSmallJsonG (smallJsont *self, baset *value); 3606 smallJsont* setTopBoolSmallJsonG (smallJsont *self, bool value); 3607 smallJsont* setTopDoubleSmallJsonG (smallJsont *self, double value); 3608 smallJsont* setTopIntSmallJsonG (smallJsont *self, int64_t value); 3609 smallJsont* setTopStringSmallJsonG (smallJsont *self, const char *value); 3610 smallJsont* setTopCharSmallJsonG (smallJsont *self, char c); 3611 smallJsont* setTopDictSmallJsonG (smallJsont *self, smallDictt *value); 3612 smallJsont* setTopArraySmallJsonG (smallJsont *self, smallArrayt *value); 3613 smallJsont* setTopArraycSmallJsonG (smallJsont *self, char **value); 3614 smallJsont* setTopCArraycSmallJsonG (smallJsont *self, const char **value); 3615 smallJsont* setTopSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3616 smallJsont* setTopSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3617 smallJsont* setTopSmallDoubleSmallJsonG(smallJsont *self, smallDoublet *value); 3618 smallJsont* setTopSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3619 smallJsont* setTopSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3620 smallJsont* setTopSmallStringSmallJsonG(smallJsont *self, smallStringt *value); 3621 smallJsont* setTopNFreeSmallJsonG (smallJsont *self, baset *value); 3622 smallJsont* setTopNFreeBoolSmallJsonG (smallJsont *self, bool value); 3623 smallJsont* setTopNFreeDoubleSmallJsonG (smallJsont *self, double value); 3624 smallJsont* setTopNFreeIntSmallJsonG (smallJsont *self, int64_t value); 3625 smallJsont* setTopNFreeStringSmallJsonG (smallJsont *self, char *value); 3626 smallJsont* setTopNFreeDictSmallJsonG (smallJsont *self, smallDictt *value); 3627 smallJsont* setTopNFreeArraySmallJsonG (smallJsont *self, smallArrayt *value); 3628 smallJsont* setTopNFreeArraycSmallJsonG (smallJsont *self, char **value); 3629 smallJsont* setTopNFreeSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3630 smallJsont* setTopNFreeSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3631 smallJsont* setTopNFreeSmallDoubleSmallJsonG(smallJsont *self, smallDoublet *value); 3632 smallJsont* setTopNFreeSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3633 smallJsont* setTopNFreeSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3634 smallJsont* setTopNFreeSmallStringSmallJsonG(smallJsont *self, smallStringt *value); 3635 3636 smallJsont* fromArraySmallJsonG (smallJsont *self, char **array, size_t size); 3637 smallJsont* fromCArraySmallJsonG(smallJsont *self, const char **array, size_t size); 3638 3639 baset* getTopSmallJsonG (smallJsont *self,baset* retType UNUSED); 3640 undefinedt* getTopUndefinedSmallJsonG (smallJsont *self,undefinedt* retType UNUSED); 3641 bool getTopBoolSmallJsonG (smallJsont *self,bool retType UNUSED); 3642 bool* getTopBoolPSmallJsonG (smallJsont *self,bool* retType UNUSED); 3643 double getTopDoubleSmallJsonG (smallJsont *self,double retType UNUSED); 3644 double* getTopDoublePSmallJsonG (smallJsont *self,double* retType UNUSED); 3645 int64_t getTopIntSmallJsonG (smallJsont *self,int64_t retType UNUSED); 3646 int64_t* getTopIntPSmallJsonG (smallJsont *self,int64_t* retType UNUSED); 3647 int32_t getTopInt32SmallJsonG (smallJsont *self,int32_t retType UNUSED); 3648 int32_t* getTopInt32PSmallJsonG (smallJsont *self,int32_t* retType UNUSED); 3649 uint64_t getTopUintSmallJsonG (smallJsont *self,uint64_t retType UNUSED); 3650 uint64_t* getTopUintPSmallJsonG (smallJsont *self,uint64_t* retType UNUSED); 3651 uint32_t getTopUint32SmallJsonG (smallJsont *self,uint32_t retType UNUSED); 3652 uint32_t* getTopUint32PSmallJsonG (smallJsont *self,uint32_t* retType UNUSED); 3653 char* getTopSSmallJsonG (smallJsont *self,char* retType UNUSED); 3654 smallDictt* getTopDictSmallJsonG (smallJsont *self,smallDictt* retType UNUSED); 3655 smallArrayt* getTopArraySmallJsonG (smallJsont *self,smallArrayt* retType UNUSED); 3656 smallBoolt* getTopSmallBoolSmallJsonG (smallJsont *self,smallBoolt* retType UNUSED); 3657 smallBytest* getTopSmallBytesSmallJsonG (smallJsont *self,smallBytest* retType UNUSED); 3658 smallDoublet* getTopSmallDoubleSmallJsonG(smallJsont *self,smallDoublet* retType UNUSED); 3659 smallIntt* getTopSmallIntSmallJsonG (smallJsont *self,smallIntt* retType UNUSED); 3660 smallStringt* getTopSmallStringSmallJsonG(smallJsont *self,smallStringt* retType UNUSED); 3661 3662 3663 smallJsont* pushSmallJsonG (smallJsont *self, baset *value); 3664 smallJsont* pushUndefinedSmallJsonG(smallJsont *self, void *value UNUSED); 3665 smallJsont* pushBoolSmallJsonG (smallJsont *self, bool value); 3666 smallJsont* pushDoubleSmallJsonG (smallJsont *self, double value); 3667 smallJsont* pushIntSmallJsonG (smallJsont *self, int64_t value); 3668 smallJsont* pushSSmallJsonG (smallJsont *self, const char *string); 3669 smallJsont* pushCharSmallJsonG (smallJsont *self, char c); 3670 smallJsont* pushDictSmallJsonG (smallJsont *self, smallDictt *dict); 3671 smallJsont* pushArraySmallJsonG (smallJsont *self, smallArrayt *array); 3672 smallJsont* pushArraycSmallJsonG (smallJsont *self, char **array); 3673 smallJsont* pushCArraycSmallJsonG (smallJsont *self, const char **array); 3674 smallJsont* pushVoidSmallJsonG (smallJsont *self, void *value); 3675 smallJsont* pushSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3676 smallJsont* pushSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3677 smallJsont* pushSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 3678 smallJsont* pushSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3679 smallJsont* pushSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3680 smallJsont* pushSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 3681 smallJsont* pushSmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 3682 3683 smallJsont* pushNFreeSmallJsonG (smallJsont *self, baset *value); 3684 smallJsont* pushNFreeUndefinedSmallJsonG (smallJsont *self, undefinedt *value); 3685 smallJsont* pushNFreeSSmallJsonG (smallJsont *self, char *string); 3686 smallJsont* pushNFreeDictSmallJsonG (smallJsont *self, smallDictt *dict); 3687 smallJsont* pushNFreeArraySmallJsonG (smallJsont *self, smallArrayt *array); 3688 smallJsont* pushNFreeArraycSmallJsonG (smallJsont *self, char **array); 3689 smallJsont* pushNFreeSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3690 smallJsont* pushNFreeSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3691 smallJsont* pushNFreeSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 3692 smallJsont* pushNFreeSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3693 smallJsont* pushNFreeSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3694 smallJsont* pushNFreeSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 3695 smallJsont* pushNFreeSmallContainerSmallJsonG (smallJsont *self, smallContainert *container); 3696 3697 baset* popSmallJsonG (smallJsont *self, baset* retType UNUSED); 3698 undefinedt* popUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED); 3699 bool popBoolSmallJsonG (smallJsont *self, bool retType UNUSED); 3700 double popDoubleSmallJsonG (smallJsont *self, double retType UNUSED); 3701 int64_t popIntSmallJsonG (smallJsont *self, int64_t retType UNUSED); 3702 int32_t popInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED); 3703 uint64_t popUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED); 3704 uint32_t popUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED); 3705 char* popSSmallJsonG (smallJsont *self, char* retType UNUSED); 3706 smallDictt* popDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED); 3707 smallArrayt* popArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED); 3708 smallBoolt* popSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED); 3709 smallBytest* popSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED); 3710 smallDoublet* popSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED); 3711 smallIntt* popSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED); 3712 smallJsont* popSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED); 3713 smallStringt* popSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED); 3714 void* popVoidSmallJsonG (smallJsont *self, void* retType UNUSED); 3715 smallContainert* popSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED); 3716 3717 3718 smallJsont* setSmallJsonG (smallJsont *self, const char *key, baset *value); 3719 smallJsont* setUndefinedSmallJsonG(smallJsont *self, const char *key, void *value UNUSED); 3720 smallJsont* setBoolSmallJsonG (smallJsont *self, const char *key, bool value); 3721 smallJsont* setDoubleSmallJsonG (smallJsont *self, const char *key, double value); 3722 smallJsont* setIntSmallJsonG (smallJsont *self, const char *key, int64_t value); 3723 smallJsont* setSSmallJsonG (smallJsont *self, const char *key, const char *string); 3724 smallJsont* setCharSmallJsonG (smallJsont *self, const char *key, char c); 3725 smallJsont* setDictSmallJsonG (smallJsont *self, const char *key, smallDictt *dict); 3726 smallJsont* setArraySmallJsonG (smallJsont *self, const char *key, smallArrayt *array); 3727 smallJsont* setArraycSmallJsonG (smallJsont *self, const char *key, char **array); 3728 smallJsont* setCArraycSmallJsonG (smallJsont *self, const char *key, const char **array); 3729 smallJsont* setVoidSmallJsonG (smallJsont *self, const char *key, void *value); 3730 smallJsont* setSmallBoolSmallJsonG (smallJsont *self, const char *key, smallBoolt *value); 3731 smallJsont* setSmallBytesSmallJsonG (smallJsont *self, const char *key, smallBytest *value); 3732 smallJsont* setSmallDoubleSmallJsonG (smallJsont *self, const char *key, smallDoublet *value); 3733 smallJsont* setSmallIntSmallJsonG (smallJsont *self, const char *key, smallIntt *value); 3734 smallJsont* setSmallJsonSmallJsonG (smallJsont *self, const char *key, smallJsont *value); 3735 smallJsont* setSmallStringSmallJsonG (smallJsont *self, const char *key, smallStringt *string); 3736 smallJsont* setSmallContainerSmallJsonG(smallJsont *self, const char *key, smallContainert *container); 3737 smallJsont* setNFreeSmallJsonG (smallJsont *self, const char *key, baset *value); 3738 smallJsont* setNFreeUndefinedSmallJsonG(smallJsont *self, const char *key, undefinedt *undefined); 3739 smallJsont* setNFreeSSmallJsonG (smallJsont *self, const char *key, char *string); 3740 smallJsont* setNFreeDictSmallJsonG (smallJsont *self, const char *key, smallDictt *dict); 3741 smallJsont* setNFreeArraySmallJsonG (smallJsont *self, const char *key, smallArrayt *array); 3742 smallJsont* setNFreeArraycSmallJsonG (smallJsont *self, const char *key, char **array); 3743 smallJsont* setNFreeSmallBoolSmallJsonG (smallJsont *self, const char *key, smallBoolt *value); 3744 smallJsont* setNFreeSmallBytesSmallJsonG (smallJsont *self, const char *key, smallBytest *value); 3745 smallJsont* setNFreeSmallDoubleSmallJsonG (smallJsont *self, const char *key, smallDoublet *value); 3746 smallJsont* setNFreeSmallIntSmallJsonG (smallJsont *self, const char *key, smallIntt *value); 3747 smallJsont* setNFreeSmallJsonSmallJsonG (smallJsont *self, const char *key, smallJsont *value); 3748 smallJsont* setNFreeSmallStringSmallJsonG (smallJsont *self, const char *key, smallStringt *string); 3749 smallJsont* setNFreeSmallContainerSmallJsonG(smallJsont *self, const char *key, smallContainert *container); 3750 3751 smallJsont* setPDictSmallJsonG (smallJsont *self, const char *key, smallDictt *dict); 3752 smallJsont* setPArraySmallJsonG (smallJsont *self, const char *key, smallArrayt *array); 3753 smallJsont* setPSmallJsonSmallJsonG (smallJsont *self, const char *key, smallJsont *value); 3754 smallJsont* setPSmallStringSmallJsonG (smallJsont *self, const char *key, smallStringt *string); 3755 smallJsont* setNFreePDictSmallJsonG (smallJsont *self, const char *key, smallDictt *dict); 3756 smallJsont* setNFreePArraySmallJsonG (smallJsont *self, const char *key, smallArrayt *array); 3757 smallJsont* setNFreePSmallJsonSmallJsonG (smallJsont *self, const char *key, smallJsont *value); 3758 smallJsont* setNFreePSmallStringSmallJsonG(smallJsont *self, const char *key, smallStringt *string); 3759 3760 smallJsont* setAtSmallJsonG (smallJsont *self, int64_t index, baset *value); 3761 smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value); 3762 smallJsont* setAtBoolSmallJsonG (smallJsont *self, int64_t index, bool value); 3763 smallJsont* setAtDoubleSmallJsonG (smallJsont *self, int64_t index, double value); 3764 smallJsont* setAtIntSmallJsonG (smallJsont *self, int64_t index, int64_t value); 3765 smallJsont* setAtSSmallJsonG (smallJsont *self, int64_t index, const char *string); 3766 smallJsont* setAtCharSmallJsonG (smallJsont *self, int64_t index, char c); 3767 smallJsont* setAtDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 3768 smallJsont* setAtArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 3769 smallJsont* setAtArraycSmallJsonG (smallJsont *self, int64_t index, char **array); 3770 smallJsont* setAtCArraycSmallJsonG (smallJsont *self, int64_t index, const char **array); 3771 smallJsont* setAtVoidSmallJsonG (smallJsont *self, int64_t index, void *value); 3772 smallJsont* setAtSmallBoolSmallJsonG (smallJsont *self, int64_t index, smallBoolt *value); 3773 smallJsont* setAtSmallBytesSmallJsonG (smallJsont *self, int64_t index, smallBytest *value); 3774 smallJsont* setAtSmallDoubleSmallJsonG (smallJsont *self, int64_t index, smallDoublet *value); 3775 smallJsont* setAtSmallIntSmallJsonG (smallJsont *self, int64_t index, smallIntt *value); 3776 smallJsont* setAtSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 3777 smallJsont* setAtSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 3778 smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container); 3779 smallJsont* setAtNFreeSmallJsonG (smallJsont *self, int64_t index, baset *value); 3780 smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value); 3781 smallJsont* setAtNFreeSSmallJsonG (smallJsont *self, int64_t index, char *string); 3782 smallJsont* setAtNFreeDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 3783 smallJsont* setAtNFreeArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 3784 smallJsont* setAtNFreeArraycSmallJsonG (smallJsont *self, int64_t index, char **array); 3785 smallJsont* setAtNFreeVoidSmallJsonG (smallJsont *self, int64_t index, void *value); 3786 smallJsont* setAtNFreeSmallBoolSmallJsonG (smallJsont *self, int64_t index, smallBoolt *value); 3787 smallJsont* setAtNFreeSmallBytesSmallJsonG (smallJsont *self, int64_t index, smallBytest *value); 3788 smallJsont* setAtNFreeSmallDoubleSmallJsonG (smallJsont *self, int64_t index, smallDoublet *value); 3789 smallJsont* setAtNFreeSmallIntSmallJsonG (smallJsont *self, int64_t index, smallIntt *value); 3790 smallJsont* setAtNFreeSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 3791 smallJsont* setAtNFreeSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 3792 smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container); 3793 3794 smallJsont* setPAtDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 3795 smallJsont* setPAtArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 3796 smallJsont* setPAtSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 3797 smallJsont* setPAtSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 3798 smallJsont* setPAtNFreeDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 3799 smallJsont* setPAtNFreeArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 3800 smallJsont* setPAtNFreeSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 3801 smallJsont* setPAtNFreeSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 3802 3803 baset* getSmallJsonG (smallJsont *self, baset* retType UNUSED, const char *key); 3804 undefinedt* getUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED, const char *key); 3805 bool getBoolSmallJsonG (smallJsont *self, bool retType UNUSED, const char *key); 3806 bool* getBoolPSmallJsonG (smallJsont *self, bool* retType UNUSED, const char *key); 3807 double getDoubleSmallJsonG (smallJsont *self, double retType UNUSED, const char *key); 3808 double* getDoublePSmallJsonG (smallJsont *self, double* retType UNUSED, const char *key); 3809 int64_t getIntSmallJsonG (smallJsont *self, int64_t retType UNUSED, const char *key); 3810 int64_t* getIntPSmallJsonG (smallJsont *self, int64_t* retType UNUSED, const char *key); 3811 int32_t getInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED, const char *key); 3812 int32_t* getInt32PSmallJsonG (smallJsont *self, int32_t* retType UNUSED, const char *key); 3813 uint64_t getUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED, const char *key); 3814 uint64_t* getUintPSmallJsonG (smallJsont *self, uint64_t* retType UNUSED, const char *key); 3815 uint32_t getUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED, const char *key); 3816 uint32_t* getUint32PSmallJsonG (smallJsont *self, uint32_t* retType UNUSED, const char *key); 3817 char* getSSmallJsonG (smallJsont *self, char* retType UNUSED, const char *key); 3818 smallDictt* getDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED, const char *key); 3819 smallArrayt* getArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED, const char *key); 3820 smallBoolt* getSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED, const char *key); 3821 smallBytest* getSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED, const char *key); 3822 smallDoublet* getSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED, const char *key); 3823 smallIntt* getSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED, const char *key); 3824 smallJsont* getSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED, const char *key); 3825 smallStringt* getSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED, const char *key); 3826 void* getVoidSmallJsonG (smallJsont *self, void* retType UNUSED, const char *key); 3827 smallContainert* getSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, const char *key); 3828 3829 baset* getNDupSmallJsonG (smallJsont *self, baset* retType UNUSED, const char *key); 3830 undefinedt* getNDupUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED, const char *key); 3831 bool getNDupBoolSmallJsonG (smallJsont *self, bool retType UNUSED, const char *key); 3832 double getNDupDoubleSmallJsonG (smallJsont *self, double retType UNUSED, const char *key); 3833 int64_t getNDupIntSmallJsonG (smallJsont *self, int64_t retType UNUSED, const char *key); 3834 int32_t getNDupInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED, const char *key); 3835 uint64_t getNDupUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED, const char *key); 3836 uint32_t getNDupUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED, const char *key); 3837 char* getNDupSSmallJsonG (smallJsont *self, char* retType UNUSED, const char *key); 3838 smallDictt* getNDupDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED, const char *key); 3839 smallArrayt* getNDupArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED, const char *key); 3840 smallBoolt* getNDupSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED, const char *key); 3841 smallBytest* getNDupSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED, const char *key); 3842 smallDoublet* getNDupSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED, const char *key); 3843 smallIntt* getNDupSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED, const char *key); 3844 smallJsont* getNDupSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED, const char *key); 3845 smallStringt* getNDupSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED, const char *key); 3846 void* getNDupVoidSmallJsonG (smallJsont *self, void* retType UNUSED, const char *key); 3847 smallContainert* getNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, const char *key); 3848 3849 baset* getAtSmallJsonG (smallJsont *self, baset* retType UNUSED, int64_t index); 3850 undefinedt* getAtUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED, int64_t index); 3851 bool getAtBoolSmallJsonG (smallJsont *self, bool retType UNUSED, int64_t index); 3852 bool* getAtBoolPSmallJsonG (smallJsont *self, bool* retType UNUSED, int64_t index); 3853 double getAtDoubleSmallJsonG (smallJsont *self, double retType UNUSED, int64_t index); 3854 double* getAtDoublePSmallJsonG (smallJsont *self, double* retType UNUSED, int64_t index); 3855 int64_t getAtIntSmallJsonG (smallJsont *self, int64_t retType UNUSED, int64_t index); 3856 int64_t* getAtIntPSmallJsonG (smallJsont *self, int64_t* retType UNUSED, int64_t index); 3857 int32_t getAtInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED, int64_t index); 3858 int32_t* getAtInt32PSmallJsonG (smallJsont *self, int32_t* retType UNUSED, int64_t index); 3859 uint64_t getAtUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED, int64_t index); 3860 uint64_t* getAtUintPSmallJsonG (smallJsont *self, uint64_t* retType UNUSED, int64_t index); 3861 uint32_t getAtUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED, int64_t index); 3862 uint32_t* getAtUint32PSmallJsonG (smallJsont *self, uint32_t* retType UNUSED, int64_t index); 3863 char* getAtSSmallJsonG (smallJsont *self, char* retType UNUSED, int64_t index); 3864 smallDictt* getAtDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED, int64_t index); 3865 smallArrayt* getAtArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED, int64_t index); 3866 smallBoolt* getAtSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED, int64_t index); 3867 smallBytest* getAtSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED, int64_t index); 3868 smallDoublet* getAtSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED, int64_t index); 3869 smallIntt* getAtSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED, int64_t index); 3870 smallJsont* getAtSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED, int64_t index); 3871 smallStringt* getAtSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED, int64_t index); 3872 void* getAtVoidSmallJsonG (smallJsont *self, void* retType UNUSED, int64_t index); 3873 smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index); 3874 3875 baset* getAtNDupSmallJsonG (smallJsont *self, baset* retType UNUSED, int64_t index); 3876 undefinedt* getAtNDupUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED, int64_t index); 3877 bool getAtNDupBoolSmallJsonG (smallJsont *self, bool retType UNUSED, int64_t index); 3878 double getAtNDupDoubleSmallJsonG (smallJsont *self, double retType UNUSED, int64_t index); 3879 int64_t getAtNDupIntSmallJsonG (smallJsont *self, int64_t retType UNUSED, int64_t index); 3880 int32_t getAtNDupInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED, int64_t index); 3881 uint64_t getAtNDupUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED, int64_t index); 3882 uint32_t getAtNDupUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED, int64_t index); 3883 char* getAtNDupSSmallJsonG (smallJsont *self, char* retType UNUSED, int64_t index); 3884 smallDictt* getAtNDupDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED, int64_t index); 3885 smallArrayt* getAtNDupArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED, int64_t index); 3886 smallBoolt* getAtNDupSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED, int64_t index); 3887 smallBytest* getAtNDupSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED, int64_t index); 3888 smallDoublet* getAtNDupSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED, int64_t index); 3889 smallIntt* getAtNDupSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED, int64_t index); 3890 smallJsont* getAtNDupSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED, int64_t index); 3891 smallStringt* getAtNDupSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED, int64_t index); 3892 void* getAtNDupVoidSmallJsonG (smallJsont *self, void* retType UNUSED, int64_t index); 3893 smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index); 3894 3895 double getNumSmallJsonG (smallJsont *self, const char *key); 3896 double getNumAtSmallJsonG (smallJsont *self, int64_t index); 3897 3898 smallJsont* delKeySmallJsonG (smallJsont *self, const char *key, int unused UNUSED); 3899 smallJsont* delElemSmallJsonG (smallJsont *self, const char *key); 3900 smallJsont* delSmallJsonG (smallJsont *self, int64_t start, int64_t end); 3901 smallJsont* delElemIndexSmallJsonG (smallJsont *self, int64_t index); 3902 smallJsont* removeKeySmallJsonG (smallJsont *self, const char *key, int unused UNUSED); 3903 smallJsont* removeElemSmallJsonG (smallJsont *self, const char *key); 3904 smallJsont* removeSmallJsonG (smallJsont *self, int64_t start, int64_t end); 3905 smallJsont* removeElemIndexSmallJsonG (smallJsont *self, int64_t index); 3906 3907 smallJsont* prependSmallJsonG (smallJsont *self, baset *value); 3908 smallJsont* prependUndefinedSmallJsonG(smallJsont *self, void *value UNUSED); 3909 smallJsont* prependBoolSmallJsonG (smallJsont *self, bool value); 3910 smallJsont* prependDoubleSmallJsonG (smallJsont *self, double value); 3911 smallJsont* prependIntSmallJsonG (smallJsont *self, int64_t value); 3912 smallJsont* prependSSmallJsonG (smallJsont *self, const char *string); 3913 smallJsont* prependCharSmallJsonG (smallJsont *self, char c); 3914 smallJsont* prependDictSmallJsonG (smallJsont *self, smallDictt *dict); 3915 smallJsont* prependArraySmallJsonG (smallJsont *self, smallArrayt *array); 3916 smallJsont* prependArraycSmallJsonG (smallJsont *self, char **array); 3917 smallJsont* prependCArraycSmallJsonG (smallJsont *self, const char **array); 3918 smallJsont* prependVoidSmallJsonG (smallJsont *self, void *value); 3919 smallJsont* prependSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3920 smallJsont* prependSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3921 smallJsont* prependSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 3922 smallJsont* prependSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3923 smallJsont* prependSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3924 smallJsont* prependSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 3925 smallJsont* prependSmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 3926 3927 smallJsont* prependNFreeSmallJsonG (smallJsont *self, baset *value); 3928 smallJsont* prependNFreeUndefinedSmallJsonG (smallJsont *self, undefinedt *value); 3929 smallJsont* prependNFreeSSmallJsonG (smallJsont *self, char *string); 3930 smallJsont* prependNFreeDictSmallJsonG (smallJsont *self, smallDictt *dict); 3931 smallJsont* prependNFreeArraySmallJsonG (smallJsont *self, smallArrayt *array); 3932 smallJsont* prependNFreeArraycSmallJsonG (smallJsont *self, char **array); 3933 smallJsont* prependNFreeSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 3934 smallJsont* prependNFreeSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 3935 smallJsont* prependNFreeSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 3936 smallJsont* prependNFreeSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 3937 smallJsont* prependNFreeSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 3938 smallJsont* prependNFreeSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 3939 smallJsont* prependNFreeSmallContainerSmallJsonG (smallJsont *self, smallContainert *container); 3940 3941 baset* dequeueSmallJsonG (smallJsont *self, baset* retType UNUSED); 3942 undefinedt* dequeueUndefinedSmallJsonG (smallJsont *self, undefinedt* retType UNUSED); 3943 bool dequeueBoolSmallJsonG (smallJsont *self, bool retType UNUSED); 3944 double dequeueDoubleSmallJsonG (smallJsont *self, double retType UNUSED); 3945 int64_t dequeueIntSmallJsonG (smallJsont *self, int64_t retType UNUSED); 3946 int32_t dequeueInt32SmallJsonG (smallJsont *self, int32_t retType UNUSED); 3947 uint64_t dequeueUintSmallJsonG (smallJsont *self, uint64_t retType UNUSED); 3948 uint32_t dequeueUint32SmallJsonG (smallJsont *self, uint32_t retType UNUSED); 3949 char* dequeueSSmallJsonG (smallJsont *self, char* retType UNUSED); 3950 smallDictt* dequeueDictSmallJsonG (smallJsont *self, smallDictt* retType UNUSED); 3951 smallArrayt* dequeueArraySmallJsonG (smallJsont *self, smallArrayt* retType UNUSED); 3952 smallBoolt* dequeueSmallBoolSmallJsonG (smallJsont *self, smallBoolt* retType UNUSED); 3953 smallBytest* dequeueSmallBytesSmallJsonG (smallJsont *self, smallBytest* retType UNUSED); 3954 smallDoublet* dequeueSmallDoubleSmallJsonG (smallJsont *self, smallDoublet* retType UNUSED); 3955 smallIntt* dequeueSmallIntSmallJsonG (smallJsont *self, smallIntt* retType UNUSED); 3956 smallJsont* dequeueSmallJsonSmallJsonG (smallJsont *self, smallJsont* retType UNUSED); 3957 smallStringt* dequeueSmallStringSmallJsonG (smallJsont *self, smallStringt* retType UNUSED); 3958 void* dequeueVoidSmallJsonG (smallJsont *self, void* retType UNUSED); 3959 smallContainert* dequeueSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED); 3960 3961 smallJsont* reverseSmallJsonG (smallJsont *self); 3962 3963 smallJsont* mergeDictSmallJsonG (smallJsont *self, smallDictt *smallDict); 3964 smallJsont* mergeDictNSmashSmallJsonG (smallJsont *self, smallDictt *smallDict); 3965 smallJsont* mergeSmallJsonG (smallJsont *self, smallJsont *smallJson); 3966 smallJsont* mergeNSmashSmallJsonG (smallJsont *self, smallJsont *smallJson); 3967 3968 smallJsont* appendSmallJsonG (smallJsont *self, smallArrayt *array); 3969 smallJsont* appendNSmashSmallJsonG (smallJsont *self, smallArrayt *array); 3970 // not used, included in mergeSmallJsonG - smallJsont* appendSmallJsonSmallJsonG (smallJsont *self, smallJsont *array); 3971 // not used, included in mergeSmallJsonG - smallJsont* appendSmallJsonNSmashSmallJsonG(smallJsont *self, smallJsont *array); 3972 smallJsont* appendArraySmallJsonG (smallJsont *self, char **array); 3973 smallJsont* appendNSmashArraySmallJsonG(smallJsont *self, char **array); 3974 smallJsont* appendCArraySmallJsonG (smallJsont *self, const char **array); 3975 smallJsont* shiftSmallJsonG (smallJsont *self, smallArrayt *array); 3976 smallJsont* shiftNSmashSmallJsonG (smallJsont *self, smallArrayt *array); 3977 smallJsont* shiftSmallJsonSmallJsonG (smallJsont *self, smallJsont *array); 3978 smallJsont* shiftNSmashSmallJsonSmallJsonG(smallJsont *self, smallJsont *array); 3979 3980 smallJsont* addSmallJsonG (smallJsont *self, smallArrayt *array); 3981 smallJsont* addJsonSmallJsonG(smallJsont *self, smallJsont *array); 3982 smallJsont* sliceSmallJsonG(smallJsont *self, int64_t start, int64_t end); 3983 smallJsont* cropSmallJsonG (smallJsont *self, int64_t start, int64_t end); 3984 char* cropSSmallJsonG (smallJsont *self, int64_t start, int64_t end); 3985 smallStringt* cropSmallStringSmallJsonG (smallJsont *self, int64_t start, int64_t end); 3986 baset* cropElemAtSmallJsonG (smallJsont *self, int64_t index); 3987 undefinedt* cropElemAtUndefinedSmallJsonG (smallJsont *self, int64_t index); 3988 bool cropElemAtBoolSmallJsonG (smallJsont *self, int64_t index); 3989 double cropElemAtDoubleSmallJsonG (smallJsont *self, int64_t index); 3990 int64_t cropElemAtIntSmallJsonG (smallJsont *self, int64_t index); 3991 int32_t cropElemAtInt32SmallJsonG (smallJsont *self, int64_t index); 3992 uint64_t cropElemAtUintSmallJsonG (smallJsont *self, int64_t index); 3993 uint32_t cropElemAtUint32SmallJsonG (smallJsont *self, int64_t index); 3994 char* cropElemAtSSmallJsonG (smallJsont *self, int64_t index); 3995 char cropElemAtCharSmallJsonG (smallJsont *self, int64_t index); 3996 smallDictt* cropElemAtDictSmallJsonG (smallJsont *self, int64_t index); 3997 smallArrayt* cropElemAtArraySmallJsonG (smallJsont *self, int64_t index); 3998 smallBoolt* cropElemAtSmallBoolSmallJsonG (smallJsont *self, int64_t index); 3999 smallBytest* cropElemAtSmallBytesSmallJsonG (smallJsont *self, int64_t index); 4000 smallDoublet* cropElemAtSmallDoubleSmallJsonG (smallJsont *self, int64_t index); 4001 smallIntt* cropElemAtSmallIntSmallJsonG (smallJsont *self, int64_t index); 4002 smallJsont* cropElemAtSmallJsonSmallJsonG (smallJsont *self, int64_t index); 4003 smallStringt* cropElemAtSmallStringSmallJsonG (smallJsont *self, int64_t index); 4004 void* cropElemAtVoidSmallJsonG (smallJsont *self, int64_t index); 4005 smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, int64_t index); 4006 baset* cropElemKeySmallJsonG (smallJsont *self, const char* key); 4007 undefinedt* cropElemKeyUndefinedSmallJsonG (smallJsont *self, const char* key); 4008 bool cropElemKeyBoolSmallJsonG (smallJsont *self, const char* key); 4009 double cropElemKeyDoubleSmallJsonG (smallJsont *self, const char* key); 4010 int64_t cropElemKeyIntSmallJsonG (smallJsont *self, const char* key); 4011 int32_t cropElemKeyInt32SmallJsonG (smallJsont *self, const char* key); 4012 uint64_t cropElemKeyUintSmallJsonG (smallJsont *self, const char* key); 4013 uint32_t cropElemKeyUint32SmallJsonG (smallJsont *self, const char* key); 4014 char* cropElemKeySSmallJsonG (smallJsont *self, const char* key); 4015 smallDictt* cropElemKeyDictSmallJsonG (smallJsont *self, const char* key); 4016 smallArrayt* cropElemKeyArraySmallJsonG (smallJsont *self, const char* key); 4017 smallBoolt* cropElemKeySmallBoolSmallJsonG (smallJsont *self, const char* key); 4018 smallBytest* cropElemKeySmallBytesSmallJsonG (smallJsont *self, const char* key); 4019 smallDoublet* cropElemKeySmallDoubleSmallJsonG (smallJsont *self, const char* key); 4020 smallIntt* cropElemKeySmallIntSmallJsonG (smallJsont *self, const char* key); 4021 smallJsont* cropElemKeySmallJsonSmallJsonG (smallJsont *self, const char* key); 4022 smallStringt* cropElemKeySmallStringSmallJsonG (smallJsont *self, const char* key); 4023 void* cropElemKeyVoidSmallJsonG (smallJsont *self, const char* key); 4024 smallContainert* cropElemKeySmallContainerSmallJsonG(smallJsont *self, const char* key); 4025 smallJsont* copySmallJsonG (smallJsont *self, int64_t start, int64_t end); 4026 smallJsont* insertSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert); 4027 smallJsont* insertNSmashSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert); 4028 smallJsont* insertSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert); 4029 smallJsont* insertNSmashSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert); 4030 smallJsont* insertStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *toInsert); 4031 smallJsont* insertSSmallJsonG (smallJsont *self, int64_t index, const char *toInsert); 4032 smallJsont* insertNFreeStringSmallJsonG(smallJsont *self, int64_t index, smallStringt *toInsert); // not used in generics 4033 smallJsont* insertNFreeSSmallJsonG (smallJsont *self, int64_t index, char *toInsert); // not used in generics 4034 4035 smallJsont* injectSmallJsonG (smallJsont *self, int64_t index, baset *value); 4036 smallJsont* injectUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value); 4037 smallJsont* injectBoolSmallJsonG (smallJsont *self, int64_t index, bool value); 4038 smallJsont* injectDoubleSmallJsonG (smallJsont *self, int64_t index, double value); 4039 smallJsont* injectIntSmallJsonG (smallJsont *self, int64_t index, int64_t value); 4040 smallJsont* injectSSmallJsonG (smallJsont *self, int64_t index, const char *string); 4041 smallJsont* injectCharSmallJsonG(smallJsont *self, int64_t index, char c); 4042 smallJsont* injectDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 4043 smallJsont* injectArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 4044 smallJsont* injectArraycSmallJsonG (smallJsont *self, int64_t index, char **array); 4045 smallJsont* injectCArraycSmallJsonG (smallJsont *self, int64_t index, const char **array); 4046 smallJsont* injectVoidSmallJsonG (smallJsont *self, int64_t index, void *value); 4047 smallJsont* injectSmallBoolSmallJsonG (smallJsont *self, int64_t index, smallBoolt *value); 4048 smallJsont* injectSmallBytesSmallJsonG (smallJsont *self, int64_t index, smallBytest *value); 4049 smallJsont* injectSmallDoubleSmallJsonG (smallJsont *self, int64_t index, smallDoublet *value); 4050 smallJsont* injectSmallIntSmallJsonG (smallJsont *self, int64_t index, smallIntt *value); 4051 smallJsont* injectSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 4052 smallJsont* injectSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 4053 smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container); 4054 smallJsont* injectNFreeSmallJsonG (smallJsont *self, int64_t index, baset *value); 4055 smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value); 4056 smallJsont* injectNFreeSSmallJsonG (smallJsont *self, int64_t index, char *string); 4057 smallJsont* injectNFreeDictSmallJsonG (smallJsont *self, int64_t index, smallDictt *dict); 4058 smallJsont* injectNFreeArraySmallJsonG (smallJsont *self, int64_t index, smallArrayt *array); 4059 smallJsont* injectNFreeArraycSmallJsonG (smallJsont *self, int64_t index, char **array); 4060 smallJsont* injectNFreeVoidSmallJsonG (smallJsont *self, int64_t index, void *value); 4061 smallJsont* injectNFreeSmallBoolSmallJsonG (smallJsont *self, int64_t index, smallBoolt *value); 4062 smallJsont* injectNFreeSmallBytesSmallJsonG (smallJsont *self, int64_t index, smallBytest *value); 4063 smallJsont* injectNFreeSmallDoubleSmallJsonG (smallJsont *self, int64_t index, smallDoublet *value); 4064 smallJsont* injectNFreeSmallIntSmallJsonG (smallJsont *self, int64_t index, smallIntt *value); 4065 smallJsont* injectNFreeSmallJsonSmallJsonG (smallJsont *self, int64_t index, smallJsont *value); 4066 smallJsont* injectNFreeSmallStringSmallJsonG (smallJsont *self, int64_t index, smallStringt *string); 4067 smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container); 4068 4069 smallJsont* uniqSmallJsonG(smallJsont *self, char c); 4070 smallJsont* icUniqSmallJsonG(smallJsont *self, char c); 4071 smallJsont* sortSmallJsonG (smallJsont *self); 4072 smallJsont* sortFSmallJsonG (smallJsont *self, shCmpt compareFunction); 4073 smallJsont* icSortSmallJsonG(smallJsont *self); 4074 4075 bool hasSmallJsonG (smallJsont *self, baset *value); 4076 bool hasUndefinedSmallJsonG(smallJsont *self, undefinedt *value); 4077 bool hasBoolSmallJsonG (smallJsont *self, bool value); 4078 bool hasDoubleSmallJsonG (smallJsont *self, double value); 4079 bool hasIntSmallJsonG (smallJsont *self, int64_t value); 4080 bool hasSSmallJsonG (smallJsont *self, const char *string); 4081 bool hasCharSmallJsonG (smallJsont *self, char c); 4082 bool hasDictSmallJsonG (smallJsont *self, smallDictt *dict); 4083 bool hasArraySmallJsonG (smallJsont *self, smallArrayt *array); 4084 bool hasArraycSmallJsonG (smallJsont *self, char **array); 4085 bool hasCArraycSmallJsonG (smallJsont *self, const char **array); 4086 bool hasSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 4087 bool hasSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 4088 bool hasSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 4089 bool hasSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 4090 bool hasSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 4091 bool hasSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4092 bool hasSmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 4093 smallJsont* findSmallJsonG (smallJsont *self, const char *needle); 4094 smallJsont* findCharSmallJsonG (smallJsont *self, char c); 4095 smallJsont* findSmallStringSmallJsonG(smallJsont *self, smallStringt *needle); 4096 smallJsont* findJsonSmallJsonG(smallJsont *self, smallJsont *needle); 4097 ssize_t indexOfSmallJsonG (smallJsont *self, baset *value); 4098 ssize_t indexOfUndefinedSmallJsonG(smallJsont *self, undefinedt *value); 4099 ssize_t indexOfBoolSmallJsonG (smallJsont *self, bool value); 4100 ssize_t indexOfDoubleSmallJsonG (smallJsont *self, double value); 4101 ssize_t indexOfIntSmallJsonG (smallJsont *self, int64_t value); 4102 ssize_t indexOfSSmallJsonG (smallJsont *self, const char *string); 4103 ssize_t indexOfCharSmallJsonG (smallJsont *self, char c); 4104 ssize_t indexOfDictSmallJsonG (smallJsont *self, smallDictt *dict); 4105 ssize_t indexOfArraySmallJsonG (smallJsont *self, smallArrayt *array); 4106 ssize_t indexOfArraycSmallJsonG (smallJsont *self, char **array); 4107 ssize_t indexOfCArraycSmallJsonG (smallJsont *self, const char **array); 4108 ssize_t indexOfSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 4109 ssize_t indexOfSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 4110 ssize_t indexOfSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 4111 ssize_t indexOfSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 4112 ssize_t indexOfSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 4113 ssize_t indexOfSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4114 ssize_t indexOfSmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 4115 ssize_t binarySearchSmallJsonG (smallJsont *self, baset *value); 4116 ssize_t binarySearchUndefinedSmallJsonG(smallJsont *self, undefinedt *value); 4117 ssize_t binarySearchBoolSmallJsonG (smallJsont *self, bool value); 4118 ssize_t binarySearchDoubleSmallJsonG (smallJsont *self, double value); 4119 ssize_t binarySearchIntSmallJsonG (smallJsont *self, int64_t value); 4120 ssize_t binarySearchSSmallJsonG (smallJsont *self, const char *string); 4121 ssize_t binarySearchCharSmallJsonG (smallJsont *self, char c); 4122 ssize_t binarySearchDictSmallJsonG (smallJsont *self, smallDictt *dict); 4123 ssize_t binarySearchArraySmallJsonG (smallJsont *self, smallArrayt *array); 4124 ssize_t binarySearchArraycSmallJsonG (smallJsont *self, char **array); 4125 ssize_t binarySearchCArraycSmallJsonG (smallJsont *self, const char **array); 4126 ssize_t binarySearchSmallBoolSmallJsonG (smallJsont *self, smallBoolt *value); 4127 ssize_t binarySearchSmallBytesSmallJsonG (smallJsont *self, smallBytest *value); 4128 ssize_t binarySearchSmallDoubleSmallJsonG (smallJsont *self, smallDoublet *value); 4129 ssize_t binarySearchSmallIntSmallJsonG (smallJsont *self, smallIntt *value); 4130 ssize_t binarySearchSmallJsonSmallJsonG (smallJsont *self, smallJsont *value); 4131 ssize_t binarySearchSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4132 ssize_t binarySearchSmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 4133 bool icHasSmallJsonG (smallJsont *self, baset *value); 4134 bool icHasSSmallJsonG (smallJsont *self, const char *string); 4135 bool icHasCharSmallJsonG (smallJsont *self, char c); 4136 bool icHasDictSmallJsonG (smallJsont *self, smallDictt *dict); 4137 bool icHasArraySmallJsonG (smallJsont *self, smallArrayt *array); 4138 bool icHasArraycSmallJsonG (smallJsont *self, char **array); 4139 bool icHasCArraycSmallJsonG (smallJsont *self, const char **array); 4140 bool icHasSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4141 smallJsont* icFindSmallJsonG (smallJsont *self, const char *needle); 4142 smallJsont* icFindCharSmallJsonG (smallJsont *self, char c); 4143 smallJsont* icFindSmallStringSmallJsonG(smallJsont *self, smallStringt *needle); 4144 smallJsont* icFindJsonSmallJsonG(smallJsont *self, smallJsont *needle); 4145 ssize_t icIndexOfSmallJsonG (smallJsont *self, baset *value); 4146 ssize_t icIndexOfSSmallJsonG (smallJsont *self, const char *string); 4147 ssize_t icIndexOfCharSmallJsonG (smallJsont *self, char c); 4148 ssize_t icIndexOfDictSmallJsonG (smallJsont *self, smallDictt *dict); 4149 ssize_t icIndexOfArraySmallJsonG (smallJsont *self, smallArrayt *array); 4150 ssize_t icIndexOfArraycSmallJsonG (smallJsont *self, char **array); 4151 ssize_t icIndexOfCArraycSmallJsonG (smallJsont *self, const char **array); 4152 ssize_t icIndexOfSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4153 ssize_t icBinarySearchSmallJsonG (smallJsont *self, baset *value); 4154 ssize_t icBinarySearchSSmallJsonG (smallJsont *self, const char *string); 4155 ssize_t icBinarySearchCharSmallJsonG (smallJsont *self, char c); 4156 ssize_t icBinarySearchDictSmallJsonG (smallJsont *self, smallDictt *dict); 4157 ssize_t icBinarySearchArraySmallJsonG (smallJsont *self, smallArrayt *array); 4158 ssize_t icBinarySearchArraycSmallJsonG (smallJsont *self, char **array); 4159 ssize_t icBinarySearchCArraycSmallJsonG (smallJsont *self, const char **array); 4160 ssize_t icBinarySearchSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4161 char* keyBySmallJsonG(smallJsont *self, baset *value); 4162 char* keyByUndefinedSmallJsonG(smallJsont *self, undefinedt *undefined); 4163 char* keyByBoolSmallJsonG(smallJsont *self, bool value); 4164 char* keyByDoubleSmallJsonG(smallJsont *self, double value); 4165 char* keyByIntSmallJsonG(smallJsont *self, int64_t value); 4166 char* keyBySSmallJsonG(smallJsont *self, const char *string); 4167 char* keyByCharSmallJsonG(smallJsont *self, char c); 4168 char* keyByDictSmallJsonG(smallJsont *self, smallDictt *dict); 4169 char* keyByArraySmallJsonG(smallJsont *self, smallArrayt *array); 4170 char* keyByArraycSmallJsonG(smallJsont *self, char **array); 4171 char* keyByCArraycSmallJsonG(smallJsont *self, const char **array); 4172 char* keyBySmallBoolSmallJsonG(smallJsont *self, smallBoolt *value); 4173 char* keyBySmallBytesSmallJsonG(smallJsont *self, smallBytest *value); 4174 char* keyBySmallDoubleSmallJsonG(smallJsont *self, smallDoublet *value); 4175 char* keyBySmallIntSmallJsonG(smallJsont *self, smallIntt *value); 4176 char* keyBySmallJsonSmallJsonG(smallJsont *self, smallJsont *value); 4177 char* keyBySmallStringSmallJsonG(smallJsont *self, smallStringt *string); 4178 char* keyBySmallContainerSmallJsonG(smallJsont *self, smallContainert *container); 4179 char* icKeyBySmallJsonG(smallJsont *self, baset *value); 4180 char* icKeyBySSmallJsonG(smallJsont *self, const char *string); 4181 char* icKeyByCharSmallJsonG(smallJsont *self, char c); 4182 char* icKeyByDictSmallJsonG(smallJsont *self, smallDictt *dict); 4183 char* icKeyByArraySmallJsonG(smallJsont *self, smallArrayt *array); 4184 char* icKeyByArraycSmallJsonG(smallJsont *self, char **array); 4185 char* icKeyByCArraycSmallJsonG(smallJsont *self, const char **array); 4186 char* icKeyBySmallStringSmallJsonG(smallJsont *self, smallStringt *string); 4187 4188 smallJsont* replaceSmallJsonG (smallJsont *self, const char *olds, const char *news, size_t max); 4189 smallJsont* replaceCharSSmallJsonG (smallJsont *self, char olds, const char *news, size_t max); 4190 smallJsont* replaceSCharSmallJsonG (smallJsont *self, const char *olds, char news, size_t max); 4191 smallJsont* replaceCharCharSmallJsonG(smallJsont *self, char olds, char news, size_t max); 4192 smallJsont* replaceSmallStringSmallStringSmallJsonG(smallJsont *self, smallStringt *olds, smallStringt *news, size_t max); 4193 smallJsont* replaceSmallStringSSmallJsonG(smallJsont *self, smallStringt *olds, const char *news, size_t max); 4194 smallJsont* replaceSmallStringCharSmallJsonG(smallJsont *self, smallStringt *olds, char news, size_t max); 4195 smallJsont* replaceSSmallStringSmallJsonG(smallJsont *self, const char *olds, smallStringt *news, size_t max); 4196 smallJsont* replaceCharSmallStringSmallJsonG(smallJsont *self, char olds, smallStringt *news, size_t max); 4197 smallJsont* replaceJsonJsonSmallJsonG (smallJsont *self, smallJsont *olds, smallJsont *news, size_t max); 4198 smallJsont* replaceJsonSmallStringSmallJsonG(smallJsont *self, smallJsont *olds, smallStringt *news, size_t max); 4199 smallJsont* replaceJsonSSmallJsonG (smallJsont *self, smallJsont *olds, const char *news, size_t max); 4200 smallJsont* replaceJsonCharSmallJsonG (smallJsont *self, smallJsont *olds, char news, size_t max); 4201 smallJsont* replaceSmallStringJsonSmallJsonG(smallJsont *self, smallStringt *olds, smallJsont *news, size_t max); 4202 smallJsont* replaceSJsonSmallJsonG (smallJsont *self, const char *olds, smallJsont *news, size_t max); 4203 smallJsont* replaceCharJsonSmallJsonG (smallJsont *self, char olds, smallJsont *news, size_t max); 4204 smallJsont* icReplaceSmallJsonG (smallJsont *self, const char *olds, const char *news, size_t max); 4205 smallJsont* icReplaceCharSSmallJsonG(smallJsont *self, char olds, const char *news, size_t max); 4206 smallJsont* icReplaceSCharSmallJsonG(smallJsont *self, const char *olds, char news, size_t max); 4207 smallJsont* icReplaceCharCharSmallJsonG(smallJsont *self, char olds, char news, size_t max); 4208 smallJsont* icReplaceSmallStringSmallStringSmallJsonG(smallJsont *self, smallStringt *olds, smallStringt *news, size_t max); 4209 smallJsont* icReplaceSmallStringSSmallJsonG(smallJsont *self, smallStringt *olds, const char *news, size_t max); 4210 smallJsont* icReplaceSmallStringCharSmallJsonG(smallJsont *self, smallStringt *olds, char news, size_t max); 4211 smallJsont* icReplaceSSmallStringSmallJsonG(smallJsont *self, const char *olds, smallStringt *news, size_t max); 4212 smallJsont* icReplaceCharSmallStringSmallJsonG(smallJsont *self, char olds, smallStringt *news, size_t max); 4213 smallJsont* icReplaceJsonJsonSmallJsonG (smallJsont *self, smallJsont *olds, smallJsont *news, size_t max); 4214 smallJsont* icReplaceJsonSmallStringSmallJsonG(smallJsont *self, smallJsont *olds, smallStringt *news, size_t max); 4215 smallJsont* icReplaceJsonSSmallJsonG (smallJsont *self, smallJsont *olds, const char *news, size_t max); 4216 smallJsont* icReplaceJsonCharSmallJsonG (smallJsont *self, smallJsont *olds, char news, size_t max); 4217 smallJsont* icReplaceSmallStringJsonSmallJsonG(smallJsont *self, smallStringt *olds, smallJsont *news, size_t max); 4218 smallJsont* icReplaceSJsonSmallJsonG (smallJsont *self, const char *olds, smallJsont *news, size_t max); 4219 smallJsont* icReplaceCharJsonSmallJsonG (smallJsont *self, char olds, smallJsont *news, size_t max); 4220 4221 bool equalSmallJsonSmallArrayG (smallJsont *self, smallArrayt *array); 4222 bool equalSmallJsonArrayG (smallJsont *self, char ** p2); 4223 bool equalSmallJsonCArrayG (smallJsont *self, const char ** p2); 4224 bool equalSmallJsonBaseG (smallJsont *self, baset* p2); 4225 bool equalSmallJsonChaG (smallJsont* self, char p2); 4226 bool equalSmallJsonCharG (smallJsont* self, const char * p2); 4227 bool equalSmallJsonBoolG (smallJsont* self, bool p2); 4228 bool equalSmallJsonDoubleG (smallJsont* self, double p2); 4229 bool equalSmallJsonInt64G (smallJsont* self, int64_t p2); 4230 bool equalSmallJsonInt32G (smallJsont* self, int32_t p2); 4231 bool equalSmallJsonUint32G (smallJsont* self, uint32_t p2); 4232 bool equalSmallJsonUint64G (smallJsont* self, uint64_t p2); 4233 bool equalSmallJsonSmallBoolG (smallJsont* self, smallBoolt* p2); 4234 bool equalSmallJsonSmallBytesG (smallJsont* self, smallBytest* p2); 4235 bool equalSmallJsonSmallDoubleG (smallJsont* self, smallDoublet* p2); 4236 bool equalSmallJsonSmallIntG (smallJsont* self, smallIntt* p2); 4237 bool equalSmallJsonSmallJsonG (smallJsont* self, smallJsont* p2); 4238 bool equalSmallJsonSmallStringG (smallJsont* self, smallStringt* p2); 4239 bool equalSmallJsonSmallDictG (smallJsont* self, smallDictt* p2); 4240 bool icEqualSmallJsonSmallArrayG (smallJsont *self, smallArrayt *array); 4241 bool icEqualSmallJsonArrayG (smallJsont *self, char ** p2); 4242 bool icEqualSmallJsonCArrayG (smallJsont *self, const char ** p2); 4243 bool icEqualSmallJsonBaseG (smallJsont *self, baset* p2); 4244 bool icEqualSmallJsonSmallDictG (smallJsont* self, smallDictt* p2); 4245 bool icEqualSmallJsonSmallJsonG (smallJsont* self, smallJsont* p2); 4246 bool icEqualSmallJsonSmallStringG(smallJsont* self, smallStringt* p2); 4247 bool icEqualCharSmallJsonG (smallJsont *self, char c); 4248 bool icEqualSSmallJsonG (smallJsont *self, const char *string); 4249 bool equalISSmallJsonG (smallJsont *self, const char *string, int64_t index); 4250 bool equalICharSmallJsonG (smallJsont *self, char c, int64_t index); 4251 bool equalIJsonSmallJsonG (smallJsont *self, smallJsont *string, int64_t index); 4252 bool equalISmallStringSmallJsonG (smallJsont *self, smallStringt *string, int64_t index); 4253 bool startsWithSSmallJsonG (smallJsont *self, const char *string); 4254 bool startsWithCharSmallJsonG (smallJsont *self, char c); 4255 bool startsWithSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4256 bool startsWithJsonSmallJsonG (smallJsont *self, smallJsont *string); 4257 bool endsWithSSmallJsonG (smallJsont *self, const char *string); 4258 bool endsWithCharSmallJsonG (smallJsont *self, char c); 4259 bool endsWithSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4260 bool endsWithJsonSmallJsonG (smallJsont *self, smallJsont *string); 4261 ssize_t countSSmallJsonG (smallJsont *self, const char *string); 4262 ssize_t countCharSmallJsonG (smallJsont *self, char c); 4263 ssize_t countSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4264 ssize_t countJsonSmallJsonG (smallJsont *self, smallJsont *string); 4265 bool icStartsWithSSmallJsonG (smallJsont *self, const char *string); 4266 bool icStartsWithCharSmallJsonG (smallJsont *self, char c); 4267 bool icStartsWithSmallStringSmallJsonG(smallJsont *self, smallStringt *string); 4268 bool icStartsWithJsonSmallJsonG (smallJsont *self, smallJsont *string); 4269 bool icEndsWithSSmallJsonG (smallJsont *self, const char *string); 4270 bool icEndsWithCharSmallJsonG (smallJsont *self, char c); 4271 bool icEndsWithSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4272 bool icEndsWithJsonSmallJsonG (smallJsont *self, smallJsont *string); 4273 ssize_t icCountSSmallJsonG (smallJsont *self, const char *string); 4274 ssize_t icCountCharSmallJsonG (smallJsont *self, char c); 4275 ssize_t icCountSmallStringSmallJsonG (smallJsont *self, smallStringt *string); 4276 ssize_t icCountJsonSmallJsonG (smallJsont *self, smallJsont *string); 4277 bool isNumberSmallJsonG (smallJsont *self); 4278 bool isIntSmallJsonG (smallJsont *self); 4279 int64_t parseIntSmallJsonG (smallJsont *self); 4280 double parseDoubleSmallJsonG (smallJsont *self); 4281 smallJsont* intToSmallJsonG (smallJsont *self, int64_t n); 4282 smallJsont* doubleToSmallJsonG (smallJsont *self, double n); 4283 size_t lenSmallJsonG (smallJsont *self); 4284 smallJsont* upperSmallJsonG (smallJsont *self); 4285 smallJsont* lowerSmallJsonG (smallJsont *self); 4286 smallJsont* trimSmallJsonG (smallJsont *self); 4287 smallJsont* lTrimSmallJsonG (smallJsont *self); 4288 smallJsont* rTrimSmallJsonG (smallJsont *self); 4289 smallJsont* compactSmallJsonG (smallJsont *self); 4290 smallJsont* emptySmallJsonG (smallJsont *self); 4291 bool isEmptySmallJsonG (smallJsont *self); 4292 bool isBlankSmallJsonG (smallJsont *self); 4293 smallStringt* joinSmallJsonG (smallJsont *self, const char* delim); 4294 smallStringt* joinCharSmallJsonG (smallJsont *self, char c); 4295 smallStringt* joinSmallJsonSmallJsonG (smallJsont *self, smallJsont* delim); 4296 smallStringt* joinSmallStringSmallJsonG(smallJsont *self, smallStringt* delim); 4297 char* joinSSmallJsonG (smallJsont *self, const char* delim); 4298 char* joinCharSSmallJsonG (smallJsont *self, char c); 4299 char* joinSmallJsonSSmallJsonG (smallJsont *self, smallJsont* delim); 4300 char* joinSmallStringSSmallJsonG(smallJsont *self, smallStringt* delim); 4301 smallJsont* splitSmallJsonG (smallJsont *self, const char *delim); 4302 smallJsont* splitCharSmallJsonG (smallJsont *self, char c); 4303 smallJsont* splitSmallJsonSmallJsonG (smallJsont *self, smallJsont *delim); 4304 smallJsont* splitSmallStringSmallJsonG(smallJsont *self, smallStringt *delim); 4305 char** splitSSmallJsonG (smallJsont *self, char* delim); 4306 char** splitCharSSmallJsonG (smallJsont *self, char c); 4307 char** splitSmallJsonSSmallJsonG (smallJsont *self, smallJsont *delim); 4308 char** splitSmallStringSSmallJsonG(smallJsont *self, smallStringt *delim); 4309 smallJsont* extractSmallJsonG(smallJsont *self, const char* delim1, const char* delim2); 4310 smallJsont* extractSmallJsonG(smallJsont *self, const char* delim1, const char* delim2); 4311 smallJsont* extractCharSSmallJsonG (smallJsont *self, char delim1, const char* delim2); 4312 smallJsont* extractSCharSmallJsonG (smallJsont *self, const char* delim1, char delim2); 4313 smallJsont* extractCharCharSmallJsonG (smallJsont *self, char delim1, char delim2); 4314 smallJsont* extractSmallJsonSmallJsonSmallJsonG (smallJsont *self, smallJsont* delim1, smallJsont* delim2); 4315 smallJsont* extractSmallJsonSmallStringSmallJsonG (smallJsont *self, smallJsont* delim1, smallStringt* delim2); 4316 smallJsont* extractSmallJsonSSmallJsonG (smallJsont *self, smallJsont* delim1, const char* delim2); 4317 smallJsont* extractSmallJsonCharSmallJsonG (smallJsont *self, smallJsont* delim1, char delim2); 4318 smallJsont* extractSmallStringSmallJsonSmallJsonG (smallJsont *self, smallStringt* delim1, smallJsont* delim2); 4319 smallJsont* extractSmallStringSmallStringSmallJsonG(smallJsont *self, smallStringt* delim1, smallStringt* delim2); 4320 smallJsont* extractSmallStringSSmallJsonG (smallJsont *self, smallStringt* delim1, const char* delim2); 4321 smallJsont* extractSmallStringCharSmallJsonG (smallJsont *self, smallStringt* delim1, char delim2); 4322 smallJsont* extractSSmallJsonSmallJsonG (smallJsont *self, const char* delim1, smallJsont* delim2); 4323 smallJsont* extractSSmallStringSmallJsonG (smallJsont *self, const char* delim1, smallStringt* delim2); 4324 smallJsont* extractCharSmallJsonSmallJsonG (smallJsont *self, char delim1, smallJsont* delim2); 4325 smallJsont* extractCharSmallStringSmallJsonG (smallJsont *self, char delim1, smallStringt* delim2); 4326 smallJsont* icSplitSmallJsonG (smallJsont *self, const char *delim); 4327 smallJsont* icSplitSmallJsonG (smallJsont *self, const char *delim); 4328 smallJsont* icSplitCharSmallJsonG (smallJsont *self, char c); 4329 smallJsont* icSplitSmallJsonSmallJsonG (smallJsont *self, smallJsont *delim); 4330 smallJsont* icSplitSmallStringSmallJsonG(smallJsont *self, smallStringt *delim); 4331 char** icSplitSSmallJsonG (smallJsont *self, char* delim); 4332 char** icSplitCharSSmallJsonG (smallJsont *self, char c); 4333 char** icSplitSmallJsonSSmallJsonG (smallJsont *self, smallJsont *delim); 4334 char** icSplitSmallStringSSmallJsonG(smallJsont *self, smallStringt *delim); 4335 smallJsont* icExtractSmallJsonG(smallJsont *self, const char* delim1, const char* delim2); 4336 smallJsont* icExtractSmallJsonG(smallJsont *self, const char* delim1, const char* delim2); 4337 smallJsont* icExtractCharSSmallJsonG (smallJsont *self, char delim1, const char* delim2); 4338 smallJsont* icExtractSCharSmallJsonG (smallJsont *self, const char* delim1, char delim2); 4339 smallJsont* icExtractCharCharSmallJsonG (smallJsont *self, char delim1, char delim2); 4340 smallJsont* icExtractSmallJsonSmallJsonSmallJsonG (smallJsont *self, smallJsont* delim1, smallJsont* delim2); 4341 smallJsont* icExtractSmallJsonSmallStringSmallJsonG (smallJsont *self, smallJsont* delim1, smallStringt* delim2); 4342 smallJsont* icExtractSmallJsonSSmallJsonG (smallJsont *self, smallJsont* delim1, const char* delim2); 4343 smallJsont* icExtractSmallJsonCharSmallJsonG (smallJsont *self, smallJsont* delim1, char delim2); 4344 smallJsont* icExtractSmallStringSmallJsonSmallJsonG (smallJsont *self, smallStringt* delim1, smallJsont* delim2); 4345 smallJsont* icExtractSmallStringSmallStringSmallJsonG(smallJsont *self, smallStringt* delim1, smallStringt* delim2); 4346 smallJsont* icExtractSmallStringSSmallJsonG (smallJsont *self, smallStringt* delim1, const char* delim2); 4347 smallJsont* icExtractSmallStringCharSmallJsonG (smallJsont *self, smallStringt* delim1, char delim2); 4348 smallJsont* icExtractSSmallJsonSmallJsonG (smallJsont *self, const char* delim1, smallJsont* delim2); 4349 smallJsont* icExtractSSmallStringSmallJsonG (smallJsont *self, const char* delim1, smallStringt* delim2); 4350 smallJsont* icExtractCharSmallJsonSmallJsonG (smallJsont *self, char delim1, smallJsont* delim2); 4351 smallJsont* icExtractCharSmallStringSmallJsonG (smallJsont *self, char delim1, smallStringt* delim2); 4352 smallJsont* zipSmallJsonG(smallJsont *self, smallArrayt *array1, smallArrayt *array2); 4353 smallJsont* zipArraySmallJsonG(smallJsont *self, char** array1, smallArrayt *array2); 4354 smallJsont* zipCArraySmallJsonG(smallJsont *self, const char** array1, smallArrayt *array2); 4355 smallJsont* zipCharSmallJsonG(smallJsont *self, smallArrayt *array1, char** array2); 4356 smallJsont* zipCCharSmallJsonG(smallJsont *self, smallArrayt *array1, const char** array2); 4357 smallJsont* zipArrayCharSmallJsonG(smallJsont *self, char** array1, char** array2); 4358 smallJsont* zipArrayCCharSmallJsonG(smallJsont *self, char** array1, const char** array2); 4359 smallJsont* zipCArrayCharSmallJsonG(smallJsont *self, const char** array1, char** array2); 4360 smallJsont* zipCArrayCCharSmallJsonG(smallJsont *self, const char** array1, const char** array2); 4361 smallJsont* zipJsonSmallJsonG (smallJsont *self, smallJsont *array1, smallJsont *array2); 4362 smallJsont* zipJsonSmallArraySmallJsonG(smallJsont *self, smallJsont *array1, smallArrayt *array2); 4363 smallJsont* zipJsonArraySmallJsonG (smallJsont *self, smallJsont *array1, char** array2); 4364 smallJsont* zipJsonCArraySmallJsonG (smallJsont *self, smallJsont *array1, const char** array2); 4365 smallJsont* zipSmallArrayJsonSmallJsonG(smallJsont *self, smallArrayt *array1, smallJsont *array2); 4366 smallJsont* zipArrayJsonSmallJsonG (smallJsont *self, char** array1, smallJsont *array2); 4367 smallJsont* zipCArrayJsonSmallJsonG (smallJsont *self, const char** array1, smallJsont *array2); 4368 smallStringt* stringifySmallStringSmallJsonG(smallJsont *self, int indent); 4369 smallStringt* toYMLSmallStringSmallJsonG (smallJsont *self, int indent); 4370 bool parseSmallJsonG (smallJsont *self, const char *input); 4371 bool parseSmallJsonSmallJsonG (smallJsont *self, smallJsont *input); 4372 bool parseSmallStringSmallJsonG (smallJsont *self, smallStringt *input); 4373 bool parseYMLSmallJsonG (smallJsont *self, const char *input); 4374 bool parseYMLSmallJsonSmallJsonG (smallJsont *self, smallJsont *input); 4375 bool parseYMLSmallStringSmallJsonG(smallJsont *self, smallStringt *input); 4376 void logSmallJsonG(smallJsont *self); 4377 smallJsont* readFileSmallJsonG (smallJsont *self, const char *filePath); 4378 smallJsont* readFileSmallStringSmallJsonG(smallJsont *self, smallStringt *filePath); 4379 smallJsont* readFileJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4380 smallJsont* readStreamSmallJsonG (smallJsont *self, FILE *fp); 4381 int writeFileSmallJsonG (smallJsont *self, const char *filePath); 4382 int writeFileSmallStringSmallJsonG(smallJsont *self, smallStringt *filePath); 4383 int writeFileJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4384 int writeStreamSmallJsonG (smallJsont *self, FILE *fp); 4385 int appendFileSmallJsonG (smallJsont *self, const char *filePath); 4386 int appendFileSmallStringSmallJsonG(smallJsont *self, smallStringt *filePath); 4387 int appendFileJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4388 smallJsont* readTextSmallJsonG (smallJsont *self, const char *filePath); 4389 smallJsont* readTextSmallStringSmallJsonG(smallJsont *self, smallStringt *filePath); 4390 smallJsont* readTextJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4391 smallJsont* readTextStreamSmallJsonG (smallJsont *self, FILE *fp); 4392 bool writeTextSmallJsonG (smallJsont *self, const char *filePath); 4393 bool writeTextSmallStringSmallJsonG (smallJsont *self, smallStringt *filePath); 4394 bool writeTextJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4395 bool writeTextStreamSmallJsonG (smallJsont *self, FILE *fp); 4396 bool appendTextSmallStringSmallJsonG(smallJsont *self, smallStringt *filePath); 4397 bool appendTextJsonSmallJsonG (smallJsont *self, smallJsont *filePath); 4398 4399 /** 4400 * forEach - loop macro on list non NULL elements 4401 * skip deleted elements 4402 */ 4403 #define forEachSmallJson(array, element) \ 4404 size_t UNIQVAR(libsheepyInternalIndex) = 0; \ 4405 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))) \ 4406 if (element) 4407 4408 /** 4409 * forEach - loop macro on smallJson keys 4410 */ 4411 #define forEachDictSmallJson(smallJson, key, value) \ 4412 char **libsheepyInternalKeys = (smallJson)->f->keys(smallJson); \ 4413 char *key = libsheepyInternalKeys[0]; \ 4414 size_t UNIQVAR(libsheepyInternalIndex) = 0; \ 4415 for (baset *value = smallJson->f->get(smallJson, key); libsheepyInternalKeys[UNIQVAR(libsheepyInternalIndex)] != NULL ; UNIQVAR(libsheepyInternalIndex)++, key = libsheepyInternalKeys[UNIQVAR(libsheepyInternalIndex)], value = smallJson->f->get(smallJson, key)) 4416 4417 /** 4418 * enumerate non NULL elements in list 4419 * skip deleted elements 4420 */ 4421 #define enumerateSmallJson(array, element, index) \ 4422 size_t index = 0; \ 4423 for (baset *element = array->f->getAt(array, 0); index < array->f->len(array) ; index++, element = array->f->getAt(array, (int64_t)index)) \ 4424 if (element) 4425 4426 // end class smallJson 4427