libsheepy
libsheepyCSmallArray.c
Go to the documentation of this file.
1 // MIT License
2 //
3 // Copyright (c) 2023 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 
23 #include "../libsheepyObject.h"
24 #include "libsheepyCSmallArray.h"
25 #include "libsheepyCSmallArrayInternal.h"
26 #include "../../release/libsheepy.h"
27 
28 #define internal static
29 
30 #include <stdio.h>
31 #include <stdarg.h>
32 #include <stdbool.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <stdint.h>
36 
37 void initiateSmallArray(smallArrayt *self);
38 void registerMethodsSmallArray(smallArrayFunctionst *f);
39 void initiateAllocateSmallArray(smallArrayt **self);
40 smallArrayt* allocSmallArray(void);
41 smallArrayt* allocArraySmallArray(char **array);
42 smallArrayt* allocCArraySmallArray(const char **array);
43 void cleanUpSmallArrayTerminateG(smallArrayt **val);
44 void cleanUpSmallArrayFreeLocalG(smallArrayt *val);
45 void cleanUpSmallArrayFreeG(smallArrayt **val);
46 void cleanUpSmallArrayFinishG(smallArrayt **val);
47 void cleanUpSmallArrayDisposeG(smallArrayt *val);
48 void cleanUpSmallArraySmashG(smallArrayt **val);
49 smallArrayt* createSAF(const char *paramType, ...);
50 void finalizeRecycleSmallArray(void *arg UNUSED);
51 void finalizeSmallArray(void);
52 internal void freeSmallArray(smallArrayt *self);
53 internal void terminateSmallArray(smallArrayt **self);
54 internal char* toStringSmallArray(smallArrayt *self);
55 internal smallArrayt* duplicateSmallArray(smallArrayt *self);
56 internal char* escapeSmallArray(smallArrayt *self);
57 internal void disposeSmallArray(smallArrayt *self);
58 internal void smashSmallArray(smallArrayt **self);
59 #if (NFreeStackCheck)
60 internal void finishSmallArray(smallArrayt **self);
61 #else
62 internal void finishSmallArray(smallArrayt **self);
63 #endif
64 internal const char* helpSmallArray(smallArrayt UNUSED *self);
65 internal void resetSmallArray(smallArrayt *self);
66 internal sArrayt* getsoSmallArray(smallArrayt *self);
67 internal void setsoSmallArray(smallArrayt *self, sArrayt *so);
68 internal smallArrayt* mirrorSmallArray(smallArrayt *self);
69 internal smallArrayt* fromArraySmallArray(smallArrayt *self, char **array, size_t size);
70 internal smallArrayt* fromCArraySmallArray(smallArrayt *self, const char **array, size_t size);
71 internal smallArrayt* fromArrayNFreeSmallArray(smallArrayt *self, char **array, size_t size);
72 internal smallArrayt* pushSmallArray(smallArrayt *self, baset *value);
73 internal smallArrayt* pushUndefinedSmallArray(smallArrayt *self);
74 internal smallArrayt* pushBoolSmallArray(smallArrayt *self, bool value);
75 internal smallArrayt* pushDoubleSmallArray(smallArrayt *self, double value);
76 internal smallArrayt* pushIntSmallArray(smallArrayt *self, int64_t value);
77 internal smallArrayt* pushSSmallArray(smallArrayt *self, const char *string);
78 internal smallArrayt* pushCharSmallArray(smallArrayt *self, char c);
79 internal smallArrayt* pushDictSmallArray(smallArrayt *self, smallDictt *dict);
80 internal smallArrayt* pushArraySmallArray(smallArrayt *self, smallArrayt *array);
81 internal smallArrayt* pushArraycSmallArray(smallArrayt *self, char **array);
82 internal smallArrayt* pushCArraycSmallArray(smallArrayt *self, const char **array);
83 internal smallArrayt* pushSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
84 internal smallArrayt* pushSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
85 internal smallArrayt* pushSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
86 internal smallArrayt* pushSmallIntSmallArray(smallArrayt *self, smallIntt *value);
87 internal smallArrayt* pushSmallJsonSmallArray(smallArrayt *self, smallJsont *value);
88 internal smallArrayt* pushSmallStringSmallArray(smallArrayt *self, smallStringt *string);
89 internal smallArrayt* pushSmallContainerSmallArray(smallArrayt *self, smallContainert *container);
90 internal smallArrayt* pushNFreeSmallArray(smallArrayt *self, baset *value);
91 internal smallArrayt* pushNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u);
92 internal smallArrayt* pushNFreeSSmallArray(smallArrayt *self, char *string);
93 internal smallArrayt* pushNFreeDictSmallArray(smallArrayt *self, smallDictt *dict);
94 internal smallArrayt* pushNFreeArraySmallArray(smallArrayt *self, smallArrayt *array);
95 internal smallArrayt* pushNFreeArraycSmallArray(smallArrayt *self, char **array);
96 internal smallArrayt* pushNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
97 internal smallArrayt* pushNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
98 internal smallArrayt* pushNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
99 internal smallArrayt* pushNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value);
100 internal smallArrayt* pushNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *value);
101 internal smallArrayt* pushNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string);
102 internal smallArrayt* pushNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container);
103 internal smallArrayt* pushManySmallArray(smallArrayt *self, ...);
104 internal smallArrayt* pushManySSmallArray(smallArrayt *self, ...);
105 internal smallArrayt* pushNFreeManySmallArray(smallArrayt *self, ...);
106 internal smallArrayt* pushNFreeManySSmallArray(smallArrayt *self, ...);
107 internal baset* popSmallArray(smallArrayt *self);
108 internal undefinedt* popUndefinedSmallArray(smallArrayt *self);
109 internal bool popBoolSmallArray(smallArrayt *self);
110 internal double popDoubleSmallArray(smallArrayt *self);
111 internal int64_t popIntSmallArray(smallArrayt *self);
112 internal int32_t popInt32SmallArray(smallArrayt *self);
113 internal uint64_t popUintSmallArray(smallArrayt *self);
114 internal uint32_t popUint32SmallArray(smallArrayt *self);
115 internal char* popSSmallArray(smallArrayt *self);
116 internal smallDictt* popDictSmallArray(smallArrayt *self);
117 internal smallArrayt* popArraySmallArray(smallArrayt *self);
118 internal smallBoolt* popSmallBoolSmallArray(smallArrayt *self);
119 internal smallBytest* popSmallBytesSmallArray(smallArrayt *self);
120 internal smallDoublet* popSmallDoubleSmallArray(smallArrayt *self);
121 internal smallIntt* popSmallIntSmallArray(smallArrayt *self);
122 internal smallJsont* popSmallJsonSmallArray(smallArrayt *self);
123 internal smallStringt* popSmallStringSmallArray(smallArrayt *self);
124 internal void* popVoidSmallArray(smallArrayt *self);
125 internal smallContainert* popSmallContainerSmallArray(smallArrayt *self);
126 internal double popNumSmallArray(smallArrayt *self);
127 internal smallArrayt* prependSmallArray(smallArrayt *self, baset *value);
128 internal smallArrayt* prependUndefinedSmallArray(smallArrayt *self);
129 internal smallArrayt* prependBoolSmallArray(smallArrayt *self, bool value);
130 internal smallArrayt* prependDoubleSmallArray(smallArrayt *self, double value);
131 internal smallArrayt* prependIntSmallArray(smallArrayt *self, int64_t value);
132 internal smallArrayt* prependSSmallArray(smallArrayt *self, const char *string);
133 internal smallArrayt* prependCharSmallArray(smallArrayt *self, char c);
134 internal smallArrayt* prependDictSmallArray(smallArrayt *self, smallDictt *dict);
135 internal smallArrayt* prependArraySmallArray(smallArrayt *self, smallArrayt *array);
136 internal smallArrayt* prependArraycSmallArray(smallArrayt *self, char **array);
137 internal smallArrayt* prependCArraycSmallArray(smallArrayt *self, const char **array);
138 internal smallArrayt* prependSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
139 internal smallArrayt* prependSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
140 internal smallArrayt* prependSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
141 internal smallArrayt* prependSmallIntSmallArray(smallArrayt *self, smallIntt *value);
142 internal smallArrayt* prependSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
143 internal smallArrayt* prependSmallStringSmallArray(smallArrayt *self, smallStringt *string);
144 internal smallArrayt* prependSmallContainerSmallArray(smallArrayt *self, smallContainert *container);
145 internal smallArrayt* prependNFreeSmallArray(smallArrayt *self, baset *value);
146 internal smallArrayt* prependNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u);
147 internal smallArrayt* prependNFreeSSmallArray(smallArrayt *self, char *string);
148 internal smallArrayt* prependNFreeDictSmallArray(smallArrayt *self, smallDictt *dict);
149 internal smallArrayt* prependNFreeArraySmallArray(smallArrayt *self, smallArrayt *array);
150 internal smallArrayt* prependNFreeArraycSmallArray(smallArrayt *self, char **array);
151 internal smallArrayt* prependNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
152 internal smallArrayt* prependNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
153 internal smallArrayt* prependNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
154 internal smallArrayt* prependNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value);
155 internal smallArrayt* prependNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
156 internal smallArrayt* prependNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string);
157 internal smallArrayt* prependNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container);
158 internal baset* dequeueSmallArray(smallArrayt *self);
159 internal undefinedt* dequeueUndefinedSmallArray(smallArrayt *self);
160 internal bool dequeueBoolSmallArray(smallArrayt *self);
161 internal double dequeueDoubleSmallArray(smallArrayt *self);
162 internal int64_t dequeueIntSmallArray(smallArrayt *self);
163 internal int32_t dequeueInt32SmallArray(smallArrayt *self);
164 internal uint64_t dequeueUintSmallArray(smallArrayt *self);
165 internal uint32_t dequeueUint32SmallArray(smallArrayt *self);
166 internal char* dequeueSSmallArray(smallArrayt *self);
167 internal smallDictt* dequeueDictSmallArray(smallArrayt *self);
168 internal smallArrayt* dequeueArraySmallArray(smallArrayt *self);
169 internal smallBoolt* dequeueSmallBoolSmallArray(smallArrayt *self);
170 internal smallBytest* dequeueSmallBytesSmallArray(smallArrayt *self);
171 internal smallDoublet* dequeueSmallDoubleSmallArray(smallArrayt *self);
172 internal smallIntt* dequeueSmallIntSmallArray(smallArrayt *self);
173 internal smallJsont* dequeueSmallJsonSmallArray(smallArrayt *self);
174 internal smallStringt* dequeueSmallStringSmallArray(smallArrayt *self);
175 internal void* dequeueVoidSmallArray(smallArrayt *self);
176 internal smallContainert* dequeueSmallContainerSmallArray(smallArrayt *self);
177 internal double dequeueNumSmallArray(smallArrayt *self);
178 internal smallArrayt* reverseSmallArray(smallArrayt *self);
179 internal smallArrayt* catSmallArray(smallArrayt *self, ...);
180 internal smallArrayt* appendSmallArray(smallArrayt *self, smallArrayt *array);
181 internal smallArrayt* appendSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
182 internal smallArrayt* appendNSmashSmallArray(smallArrayt *self, smallArrayt *array);
183 internal smallArrayt* appendNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
184 internal smallArrayt* appendArraySmallArray(smallArrayt *self, char **array);
185 internal smallArrayt* appendCArraySmallArray(smallArrayt *self, const char **array);
186 internal smallArrayt* appendNSmashArraySmallArray(smallArrayt *self, char **array);
187 internal smallArrayt* shiftSmallArray(smallArrayt *self, smallArrayt *array);
188 internal smallArrayt* shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
189 internal smallArrayt* shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array);
190 internal smallArrayt* shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
191 internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array);
192 internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end);
193 internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end);
194 internal baset* cropElemSmallArray(smallArrayt *self, int64_t index);
195 internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index);
196 internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index);
197 internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index);
198 internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index);
199 internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index);
200 internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index);
201 internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index);
202 internal char* cropElemSSmallArray(smallArrayt *self, int64_t index);
203 internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index);
204 internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index);
205 internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index);
206 internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index);
207 internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index);
208 internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index);
209 internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index);
210 internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index);
211 internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index);
212 internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index);
213 internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end);
214 internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert);
215 internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert);
216 internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert);
217 internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert);
218 internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject);
219 internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index);
220 internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject);
221 internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject);
222 internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject);
223 internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject);
224 internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c);
225 internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject);
226 internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject);
227 internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject);
228 internal smallArrayt* injectCArraycSmallArray(smallArrayt *self, int64_t index, const char **toInject);
229 internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject);
230 internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject);
231 internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject);
232 internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject);
233 internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject);
234 internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject);
235 internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject);
236 internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject);
237 internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u);
238 internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject);
239 internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject);
240 internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject);
241 internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject);
242 internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject);
243 internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject);
244 internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject);
245 internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject);
246 internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject);
247 internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject);
248 internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject);
249 internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end);
250 internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index);
251 internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end);
252 internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index);
253 internal int sortSCmp(const void * a, const void * b);
254 internal smallArrayt* sortSmallArray(smallArrayt *self);
255 #if (__APPLE__ || __FreeBSD__ || __DragonFly__)
256 internal int sortFCmp(void *func, const void *a, const void *b);
257 #else
258 internal int sortFCmp(const void *a, const void *b, void *func);
259 #endif
260 internal int icSortSCmp(const void * a, const void * b);
261 internal smallArrayt* icSortSmallArray(smallArrayt *self);
262 #if (__APPLE__ || __FreeBSD__ || __DragonFly__)
263 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction);
264 #else
265 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction);
266 #endif
267 internal bool equalSmallArray(smallArrayt *self, smallArrayt *array);
268 internal bool equalSmallArraySmallJson(smallArrayt *self, smallJsont *array);
269 internal bool equalSmallArrayArray(smallArrayt* self, char ** p2);
270 internal bool equalSmallArrayCArray(smallArrayt* self, const char ** p2);
271 internal bool equalSmallArrayBase(smallArrayt* self, baset* p2);
272 internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array);
273 internal bool icEqualSmallArraySmallJson(smallArrayt *self, smallJsont *array);
274 bool icEqualSmallArrayArray(smallArrayt* self, char ** p2);
275 bool icEqualSmallArrayCArray(smallArrayt* self, const char ** p2);
276 bool icEqualSmallArrayBase(smallArrayt* self, baset* p2);
277 internal size_t lenSmallArray(smallArrayt *self);
278 internal smallArrayt* trimSmallArray(smallArrayt *self);
279 baset* getAtSmallArray(smallArrayt *self, int64_t index);
280 internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index);
281 internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index);
282 internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index);
283 internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index);
284 internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index);
285 internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index);
286 internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index);
287 internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index);
288 internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index);
289 internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index);
290 internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index);
291 internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index);
292 internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index);
293 internal char* getAtSSmallArray(smallArrayt *self, int64_t index);
294 internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index);
295 internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index);
296 internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index);
297 internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index);
298 internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index);
299 internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index);
300 internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index);
301 internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index);
302 internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index);
303 internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index);
304 baset* getAtNDupSmallArray(smallArrayt *self, int64_t index);
305 internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index);
306 internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index);
307 internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index);
308 internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index);
309 internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index);
310 internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index);
311 internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index);
312 internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index);
313 internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index);
314 internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index);
315 internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index);
316 internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index);
317 internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index);
318 internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index);
319 internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index);
320 internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index);
321 internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index);
322 internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index);
323 internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value);
324 internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index);
325 internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value);
326 internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value);
327 internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value);
328 internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string);
329 internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c);
330 internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
331 internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
332 internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array);
333 internal smallArrayt* setAtCArraycSmallArray(smallArrayt *self, int64_t index, const char **array);
334 internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value);
335 internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value);
336 internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value);
337 internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value);
338 internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value);
339 internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
340 internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container);
341 internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value);
342 internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u);
343 internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string);
344 internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
345 internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
346 internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array);
347 internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value);
348 internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value);
349 internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value);
350 internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value);
351 internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value);
352 internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
353 internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container);
354 internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
355 internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
356 internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json);
357 internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
358 internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
359 internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
360 internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json);
361 internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
362 internal double getNumSmallArray(smallArrayt *self, int64_t index);
363 internal bool hasSmallArray(smallArrayt *self, baset *value);
364 internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *u);
365 internal bool hasBoolSmallArray(smallArrayt *self, bool value);
366 internal bool hasDoubleSmallArray(smallArrayt *self, double value);
367 internal bool hasIntSmallArray(smallArrayt *self, int64_t value);
368 internal bool hasSSmallArray(smallArrayt *self, const char *string);
369 internal bool hasCharSmallArray(smallArrayt *self, char c);
370 internal bool hasDictSmallArray(smallArrayt *self, smallDictt *dict);
371 internal bool hasArraySmallArray(smallArrayt *self, smallArrayt *array);
372 internal bool hasArraycSmallArray(smallArrayt *self, char **array);
373 internal bool hasCArraycSmallArray(smallArrayt *self, const char **array);
374 internal bool hasSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
375 internal bool hasSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
376 internal bool hasSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
377 internal bool hasSmallIntSmallArray(smallArrayt *self, smallIntt *value);
378 internal bool hasSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
379 internal bool hasSmallStringSmallArray(smallArrayt *self, smallStringt *string);
380 internal bool hasSmallContainerSmallArray(smallArrayt *self, smallContainert *container);
381 internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value);
382 internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *u);
383 internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value);
384 internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value);
385 internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value);
386 internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string);
387 internal ssize_t indexOfCharSmallArray(smallArrayt *self, char c);
388 internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict);
389 internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array);
390 internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array);
391 internal ssize_t indexOfCArraycSmallArray(smallArrayt *self, const char **array);
392 internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
393 internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
394 internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
395 internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value);
396 internal ssize_t indexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
397 internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string);
398 internal ssize_t indexOfSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED);
399 internal ssize_t binarySearchSmallArray(smallArrayt *self, baset *value);
400 internal ssize_t binarySearchUndefinedSmallArray(smallArrayt *self UNUSED, undefinedt *u UNUSED);
401 internal ssize_t binarySearchBoolSmallArray(smallArrayt *self, bool value);
402 internal ssize_t binarySearchDoubleSmallArray(smallArrayt *self, double value);
403 internal ssize_t binarySearchIntSmallArray(smallArrayt *self, int64_t value);
404 internal ssize_t binarySearchSSmallArray(smallArrayt *self, const char *string);
405 internal ssize_t binarySearchCharSmallArray(smallArrayt *self, char c);
406 internal ssize_t binarySearchDictSmallArray(smallArrayt *self, smallDictt *dict);
407 internal ssize_t binarySearchArraySmallArray(smallArrayt *self, smallArrayt *array);
408 internal ssize_t binarySearchArraycSmallArray(smallArrayt *self, char **array);
409 internal ssize_t binarySearchCArraycSmallArray(smallArrayt *self, const char **array);
410 internal ssize_t binarySearchSmallBoolSmallArray(smallArrayt *self, smallBoolt *value);
411 internal ssize_t binarySearchSmallBytesSmallArray(smallArrayt *self, smallBytest *value);
412 internal ssize_t binarySearchSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value);
413 internal ssize_t binarySearchSmallIntSmallArray(smallArrayt *self, smallIntt *value);
414 internal ssize_t binarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
415 internal ssize_t binarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string);
416 internal ssize_t binarySearchSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED);
417 internal smallArrayt* uniqSmallArray(smallArrayt *self);
418 internal bool icHasSmallArray(smallArrayt *self, baset *value);
419 internal bool icHasSSmallArray(smallArrayt *self, const char *string);
420 internal bool icHasCharSmallArray(smallArrayt *self, char c);
421 internal bool icHasDictSmallArray(smallArrayt *self, smallDictt *dict);
422 internal bool icHasArraySmallArray(smallArrayt *self, smallArrayt *array);
423 internal bool icHasArraycSmallArray(smallArrayt *self, char **array);
424 internal bool icHasCArraycSmallArray(smallArrayt *self, const char **array);
425 internal bool icHasSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
426 internal bool icHasSmallStringSmallArray(smallArrayt *self, smallStringt *string);
427 internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value);
428 internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string);
429 internal ssize_t icIndexOfCharSmallArray(smallArrayt *self, char c);
430 internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict);
431 internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array);
432 internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array);
433 internal ssize_t icIndexOfCArraycSmallArray(smallArrayt *self, const char **array);
434 internal ssize_t icIndexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
435 internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string);
436 internal ssize_t icBinarySearchSmallArray(smallArrayt *self, baset *value);
437 internal ssize_t icBinarySearchSSmallArray(smallArrayt *self, const char *string);
438 internal ssize_t icBinarySearchCharSmallArray(smallArrayt *self, char c);
439 internal ssize_t icBinarySearchDictSmallArray(smallArrayt *self, smallDictt *dict);
440 internal ssize_t icBinarySearchArraySmallArray(smallArrayt *self, smallArrayt *array);
441 internal ssize_t icBinarySearchArraycSmallArray(smallArrayt *self, char **array);
442 internal ssize_t icBinarySearchCArraycSmallArray(smallArrayt *self, const char **array);
443 internal ssize_t icBinarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string);
444 internal ssize_t icBinarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string);
445 internal smallArrayt* icUniqSmallArray(smallArrayt *self);
446 internal smallArrayt* compactSmallArray(smallArrayt *self);
447 internal smallArrayt* emptySmallArray(smallArrayt *self);
448 internal bool isEmptySmallArray(smallArrayt *self);
449 internal bool isBlankSmallArray(smallArrayt *self);
450 internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem);
451 internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem);
452 internal baset* iterStartSmallArray(smallArrayt *self);
453 internal baset* iterStartLastSmallArray(smallArrayt *self);
454 internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index);
455 internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step);
456 internal baset* iterNextSmallArray(smallArrayt *self);
457 internal baset* iterElementSmallArray(smallArrayt *self);
458 internal ssize_t iterIndexSmallArray(smallArrayt *self);
459 internal int64_t iterStepSmallArray(smallArrayt *self);
460 internal smallStringt* joinSmallArray(smallArrayt *self, const char* delim);
461 internal smallStringt* joinCharSmallArray(smallArrayt *self, char c);
462 internal smallStringt* joinSmallJsonSmallArray(smallArrayt *self, smallJsont* delim);
463 internal smallStringt* joinSmallStringSmallArray(smallArrayt *self, smallStringt* delim);
464 internal char* joinSSmallArray(smallArrayt *self, const char* delim);
465 internal char* joinCharSSmallArray(smallArrayt *self, char c);
466 internal char* joinSmallJsonSSmallArray(smallArrayt *self, smallJsont* delim);
467 internal char* joinSmallStringSSmallArray(smallArrayt *self, smallStringt* delim);
468 internal smallArrayt* zipSmallArray(smallArrayt *self, smallArrayt *array1, smallArrayt *array2);
469 internal smallArrayt* zipSmallJsonSmallArray(smallArrayt *self, smallArrayt *array1, smallJsont *array2);
470 internal smallArrayt* zipSmallJsonSmallArraySmallArray(smallArrayt *self, smallJsont *array1, smallArrayt *array2);
471 internal smallArrayt* zipSmallJsonSmallJsonSmallArray(smallArrayt *self, smallJsont *array1, smallJsont *array2);
472 internal smallArrayt* zipSmallJsonCharSmallArray(smallArrayt *self, smallJsont *array1, char **array2);
473 internal smallArrayt* zipSmallJsonCCharSmallArray(smallArrayt *self, smallJsont *array1, const char **array2);
474 internal smallArrayt* zipArraySmallArray(smallArrayt *self, char** array1, smallArrayt *array2);
475 internal smallArrayt* zipCArraySmallArray(smallArrayt *self, const char** array1, smallArrayt *array2);
476 internal smallArrayt* zipArraySmallJsonSmallArray(smallArrayt *self, char** array1, smallJsont *array2);
477 internal smallArrayt* zipCArraySmallJsonSmallArray(smallArrayt *self, const char** array1, smallJsont *array2);
478 internal smallArrayt* zipCharSmallArray(smallArrayt *self, smallArrayt *array1, char** array2);
479 internal smallArrayt* zipCCharSmallArray(smallArrayt *self, smallArrayt *array1, const char** array2);
480 internal smallArrayt* zipArrayCharSmallArray(smallArrayt *self, char** array1, char** array2);
481 internal smallArrayt* zipCArrayCharSmallArray(smallArrayt *self, const char** array1, char** array2);
482 internal smallArrayt* zipArrayCCharSmallArray(smallArrayt *self, char** array1, const char** array2);
483 internal smallArrayt* zipCArrayCCharSmallArray(smallArrayt *self, const char** array1, const char** array2);
484 internal void logSmallArray(smallArrayt *self);
485 internal smallArrayt* readTextSmallArray(smallArrayt *self, const char *filePath);
486 internal smallArrayt* readTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath);
487 internal smallArrayt* readTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath);
488 internal smallArrayt* readStreamSmallArray(smallArrayt *self, FILE *fp);
489 internal bool writeTextSmallArray(smallArrayt *self, const char *filePath);
490 internal bool writeTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath);
491 internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath);
492 internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp);
493 internal bool appendTextSmallArray(smallArrayt *self, const char *filePath);
494 internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath);
495 internal const char* typeStringSmallArray(smallArrayt *self, int64_t index);
496 internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index);
497 internal char typeSmallArray(smallArrayt *self, int64_t index);
498 internal const char** typeStringsSmallArray(smallArrayt *self);
499 internal smallArrayt* typeSmallStringsSmallArray(smallArrayt *self);
500 internal smallBytest* typesSmallArray(smallArrayt *self);
501 internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type);
502 internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index);
503 internal bool isEBoolSmallArray(smallArrayt *self, int64_t index);
504 internal bool isEContainerSmallArray(smallArrayt *self, int64_t index);
505 internal bool isEDictSmallArray(smallArrayt *self, int64_t index);
506 internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index);
507 internal bool isEIntSmallArray(smallArrayt *self, int64_t index);
508 internal bool isEStringSmallArray(smallArrayt *self, int64_t index);
509 internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index);
510 internal bool isEArraySmallArray(smallArrayt *self, int64_t index);
511 internal bool isEBytesSmallArray(smallArrayt *self, int64_t index);
512 internal bool areAllETypeSmallArray(smallArrayt *self, const char *type);
513 internal bool areAllEUndefinedSmallArray(smallArrayt *self);
514 internal bool areAllEBoolSmallArray(smallArrayt *self);
515 internal bool areAllEContainerSmallArray(smallArrayt *self);
516 internal bool areAllEDictSmallArray(smallArrayt *self);
517 internal bool areAllEDoubleSmallArray(smallArrayt *self);
518 internal bool areAllEIntSmallArray(smallArrayt *self);
519 internal bool areAllEStringSmallArray(smallArrayt *self);
520 internal bool areAllEFaststringSmallArray(smallArrayt *self);
521 internal bool areAllEArraySmallArray(smallArrayt *self);
522 internal bool areAllEBytesSmallArray(smallArrayt *self);
523 smallArrayt* allocSmallArrayG(smallArrayt *self UNUSED);
524 smallArrayt* duplicateSmallArrayG (smallArrayt *self);
525 smallArrayt* fromArraySmallArrayG (smallArrayt *self, char **array, size_t size);
526 smallArrayt* fromCArraySmallArrayG (smallArrayt *self, const char **array, size_t size);
527 smallArrayt* setFromSmallArrayG(smallArrayt *self, char **array);
528 smallArrayt* setFromCSmallArrayG(smallArrayt *self, const char **array);
529 smallArrayt* pushSmallArrayG (smallArrayt *self, baset *value);
530 smallArrayt* pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED);
531 smallArrayt* pushBoolSmallArrayG (smallArrayt *self, bool value);
532 smallArrayt* pushDoubleSmallArrayG (smallArrayt *self, double value);
533 smallArrayt* pushIntSmallArrayG (smallArrayt *self, int64_t value);
534 smallArrayt* pushSSmallArrayG (smallArrayt *self, const char *string);
535 smallArrayt* pushCharSmallArrayG(smallArrayt *self, char c);
536 smallArrayt* pushDictSmallArrayG (smallArrayt *self, smallDictt *dict);
537 smallArrayt* pushArraySmallArrayG (smallArrayt *self, smallArrayt *array);
538 smallArrayt* pushArraycSmallArrayG (smallArrayt *self, char **array);
539 smallArrayt* pushCArraycSmallArrayG (smallArrayt *self, const char **array);
540 smallArrayt* pushVoidSmallArrayG (smallArrayt *self, void *value);
541 smallArrayt* pushSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
542 smallArrayt* pushSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
543 smallArrayt* pushSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
544 smallArrayt* pushSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
545 smallArrayt* pushSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value);
546 smallArrayt* pushSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
547 smallArrayt* pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
548 smallArrayt* pushNFreeSmallArrayG (smallArrayt *self, baset *value);
549 smallArrayt* pushNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value);
550 smallArrayt* pushNFreeSSmallArrayG (smallArrayt *self, char *string);
551 smallArrayt* pushNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict);
552 smallArrayt* pushNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array);
553 smallArrayt* pushNFreeArraycSmallArrayG (smallArrayt *self, char **array);
554 smallArrayt* pushNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
555 smallArrayt* pushNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
556 smallArrayt* pushNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
557 smallArrayt* pushNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
558 smallArrayt* pushNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value);
559 smallArrayt* pushNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
560 smallArrayt* pushNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
561 baset* popSmallArrayG (smallArrayt *self, baset* retType UNUSED);
562 undefinedt* popUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED);
563 bool popBoolSmallArrayG (smallArrayt *self, bool retType UNUSED);
564 double popDoubleSmallArrayG (smallArrayt *self, double retType UNUSED);
565 int64_t popIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED);
566 int32_t popInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED);
567 uint64_t popUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED);
568 uint32_t popUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED);
569 char* popSSmallArrayG (smallArrayt *self, char* retType UNUSED);
570 smallDictt* popDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED);
571 smallArrayt* popArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED);
572 smallBoolt* popSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED);
573 smallBytest* popSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED);
574 smallDoublet* popSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED);
575 smallIntt* popSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED);
576 smallJsont* popSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED);
577 smallStringt* popSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED);
578 void* popVoidSmallArrayG (smallArrayt *self, void* retType UNUSED);
579 smallContainert* popSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED);
580 smallArrayt* prependSmallArrayG (smallArrayt *self, baset *value);
581 smallArrayt* prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED);
582 smallArrayt* prependBoolSmallArrayG (smallArrayt *self, bool value);
583 smallArrayt* prependDoubleSmallArrayG (smallArrayt *self, double value);
584 smallArrayt* prependIntSmallArrayG (smallArrayt *self, int64_t value);
585 smallArrayt* prependSSmallArrayG (smallArrayt *self, const char *string);
586 smallArrayt* prependCharSmallArrayG(smallArrayt *self, char c);
587 smallArrayt* prependDictSmallArrayG (smallArrayt *self, smallDictt *dict);
588 smallArrayt* prependArraySmallArrayG (smallArrayt *self, smallArrayt *array);
589 smallArrayt* prependArraycSmallArrayG (smallArrayt *self, char **array);
590 smallArrayt* prependCArraycSmallArrayG (smallArrayt *self, const char **array);
591 smallArrayt* prependVoidSmallArrayG (smallArrayt *self, void *value);
592 smallArrayt* prependSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
593 smallArrayt* prependSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
594 smallArrayt* prependSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
595 smallArrayt* prependSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
596 smallArrayt* prependSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
597 smallArrayt* prependSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
598 smallArrayt* prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
599 smallArrayt* prependNFreeSmallArrayG (smallArrayt *self, baset *value);
600 smallArrayt* prependNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value);
601 smallArrayt* prependNFreeSSmallArrayG (smallArrayt *self, char *string);
602 smallArrayt* prependNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict);
603 smallArrayt* prependNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array);
604 smallArrayt* prependNFreeArraycSmallArrayG (smallArrayt *self, char **array);
605 smallArrayt* prependNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
606 smallArrayt* prependNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
607 smallArrayt* prependNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
608 smallArrayt* prependNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
609 smallArrayt* prependNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
610 smallArrayt* prependNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
611 smallArrayt* prependNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
612 baset* dequeueSmallArrayG (smallArrayt *self, baset* retType UNUSED);
613 undefinedt* dequeueUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED);
614 bool dequeueBoolSmallArrayG (smallArrayt *self, bool retType UNUSED);
615 double dequeueDoubleSmallArrayG (smallArrayt *self, double retType UNUSED);
616 int64_t dequeueIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED);
617 int32_t dequeueInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED);
618 uint64_t dequeueUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED);
619 uint32_t dequeueUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED);
620 char* dequeueSSmallArrayG (smallArrayt *self, char* retType UNUSED);
621 smallDictt* dequeueDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED);
622 smallArrayt* dequeueArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED);
623 smallBoolt* dequeueSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED);
624 smallBytest* dequeueSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED);
625 smallDoublet* dequeueSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED);
626 smallIntt* dequeueSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED);
627 smallJsont* dequeueSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED);
628 smallStringt* dequeueSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED);
629 void* dequeueVoidSmallArrayG (smallArrayt *self, void* retType UNUSED);
630 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED);
631 baset* getAtSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index);
632 undefinedt* getAtUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
633 bool getAtBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index);
634 bool* getAtBoolPSmallArrayG (smallArrayt *self, bool* retType UNUSED, int64_t index);
635 double getAtDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index);
636 double* getAtDoublePSmallArrayG (smallArrayt *self, double* retType UNUSED, int64_t index);
637 int64_t getAtIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index);
638 int64_t* getAtIntPSmallArrayG (smallArrayt *self, int64_t* retType UNUSED, int64_t index);
639 int32_t getAtInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index);
640 int32_t* getAtInt32PSmallArrayG (smallArrayt *self, int32_t* retType UNUSED, int64_t index);
641 uint64_t getAtUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
642 uint64_t* getAtUintPSmallArrayG (smallArrayt *self, uint64_t* retType UNUSED, int64_t index);
643 uint32_t getAtUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
644 uint32_t* getAtUint32PSmallArrayG (smallArrayt *self, uint32_t* retType UNUSED, int64_t index);
645 char* getAtSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index);
646 smallDictt* getAtDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
647 smallArrayt* getAtArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
648 smallBoolt* getAtSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
649 smallBytest* getAtSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
650 smallDoublet* getAtSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
651 smallIntt* getAtSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
652 smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
653 smallStringt* getAtSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
654 void* getAtVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index);
655 smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
656 baset* getAtNDupSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index);
657 undefinedt* getAtNDupUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
658 bool getAtNDupBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index);
659 double getAtNDupDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index);
660 int64_t getAtNDupIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index);
661 int32_t getAtNDupInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index);
662 uint64_t getAtNDupUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
663 uint32_t getAtNDupUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
664 char* getAtNDupSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index);
665 smallDictt* getAtNDupDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
666 smallArrayt* getAtNDupArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
667 smallBoolt* getAtNDupSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
668 smallBytest* getAtNDupSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
669 smallDoublet* getAtNDupSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
670 smallIntt* getAtNDupSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
671 smallJsont* getAtNDupSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
672 smallStringt* getAtNDupSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
673 void* getAtNDupVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index);
674 smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
675 smallArrayt* setAtSmallArrayG (smallArrayt *self, int64_t index, baset *value);
676 smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED);
677 smallArrayt* setAtBoolSmallArrayG (smallArrayt *self, int64_t index, bool value);
678 smallArrayt* setAtDoubleSmallArrayG (smallArrayt *self, int64_t index, double value);
679 smallArrayt* setAtIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value);
680 smallArrayt* setAtSSmallArrayG (smallArrayt *self, int64_t index, const char *string);
681 smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c);
682 smallArrayt* setAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
683 smallArrayt* setAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
684 smallArrayt* setAtArraycSmallArrayG (smallArrayt *self, int64_t index, char **array);
685 smallArrayt* setAtCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array);
686 smallArrayt* setAtVoidSmallArrayG (smallArrayt *self, int64_t index, void *value);
687 smallArrayt* setAtSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value);
688 smallArrayt* setAtSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value);
689 smallArrayt* setAtSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value);
690 smallArrayt* setAtSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value);
691 smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value);
692 smallArrayt* setAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
693 smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
694 smallArrayt* setAtNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value);
695 smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
696 smallArrayt* setAtNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string);
697 smallArrayt* setAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
698 smallArrayt* setAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
699 smallArrayt* setAtNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array);
700 smallArrayt* setAtNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value);
701 smallArrayt* setAtNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value);
702 smallArrayt* setAtNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value);
703 smallArrayt* setAtNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value);
704 smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value);
705 smallArrayt* setAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
706 smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
707 smallArrayt* setPAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
708 smallArrayt* setPAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
709 smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json);
710 smallArrayt* setPAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
711 smallArrayt* setPAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
712 smallArrayt* setPAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
713 smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json);
714 smallArrayt* setPAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
715 double getNumSmallArrayG(smallArrayt *self, int64_t index);
716 smallArrayt* reverseSmallArrayG (smallArrayt *self);
717 smallArrayt* appendSmallArrayG (smallArrayt *self, smallArrayt *array);
718 smallArrayt* appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
719 smallArrayt* appendNSmashSmallArrayG (smallArrayt *self, smallArrayt *array);
720 smallArrayt* appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
721 smallArrayt* appendArraySmallArrayG (smallArrayt *self, char **array);
722 smallArrayt* appendNSmashArraySmallArrayG (smallArrayt *self, char **array);
723 smallArrayt* appendCArraySmallArrayG (smallArrayt *self, const char **array);
724 smallArrayt* shiftSmallArrayG (smallArrayt *self, smallArrayt *array);
725 smallArrayt* shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
726 smallArrayt* shiftNSmashSmallArrayG (smallArrayt *self, smallArrayt *array);
727 smallArrayt* shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
728 smallArrayt* addSmallArrayG (smallArrayt *self, smallArrayt *array);
729 smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end);
730 smallArrayt* cropSmallArrayG (smallArrayt *self, int64_t start, int64_t end);
731 baset* cropElemSmallArrayG (smallArrayt *self, int64_t index);
732 undefinedt* cropElemUndefinedSmallArrayG (smallArrayt *self, int64_t index);
733 bool cropElemBoolSmallArrayG (smallArrayt *self, int64_t index);
734 double cropElemDoubleSmallArrayG (smallArrayt *self, int64_t index);
735 int64_t cropElemIntSmallArrayG (smallArrayt *self, int64_t index);
736 int32_t cropElemInt32SmallArrayG (smallArrayt *self, int64_t index);
737 uint64_t cropElemUintSmallArrayG (smallArrayt *self, int64_t index);
738 uint32_t cropElemUint32SmallArrayG (smallArrayt *self, int64_t index);
739 char* cropElemSSmallArrayG (smallArrayt *self, int64_t index);
740 smallDictt* cropElemDictSmallArrayG (smallArrayt *self, int64_t index);
741 smallArrayt* cropElemArraySmallArrayG (smallArrayt *self, int64_t index);
742 smallBoolt* cropElemSmallBoolSmallArrayG (smallArrayt *self, int64_t index);
743 smallBytest* cropElemSmallBytesSmallArrayG (smallArrayt *self, int64_t index);
744 smallDoublet* cropElemSmallDoubleSmallArrayG (smallArrayt *self, int64_t index);
745 smallIntt* cropElemSmallIntSmallArrayG (smallArrayt *self, int64_t index);
746 smallJsont* cropElemSmallJsonSmallArrayG (smallArrayt *self, int64_t index);
747 smallStringt* cropElemSmallStringSmallArrayG (smallArrayt *self, int64_t index);
748 void* cropElemVoidSmallArrayG (smallArrayt *self, int64_t index);
749 smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index);
750 smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end);
751 smallArrayt* insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert);
752 smallArrayt* insertSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *toInsert);
753 smallArrayt* insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert);
754 smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert);
755 smallArrayt* injectSmallArrayG (smallArrayt *self, int64_t index, baset *value);
756 smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED);
757 smallArrayt* injectBoolSmallArrayG (smallArrayt *self, int64_t index, bool value);
758 smallArrayt* injectDoubleSmallArrayG (smallArrayt *self, int64_t index, double value);
759 smallArrayt* injectIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value);
760 smallArrayt* injectSSmallArrayG (smallArrayt *self, int64_t index, const char *string);
761 smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c);
762 smallArrayt* injectDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
763 smallArrayt* injectArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
764 smallArrayt* injectArraycSmallArrayG (smallArrayt *self, int64_t index, char **array);
765 smallArrayt* injectCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array);
766 smallArrayt* injectVoidSmallArrayG (smallArrayt *self, int64_t index, void *value);
767 smallArrayt* injectSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value);
768 smallArrayt* injectSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value);
769 smallArrayt* injectSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value);
770 smallArrayt* injectSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value);
771 smallArrayt* injectSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string);
772 smallArrayt* injectSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
773 smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
774 smallArrayt* injectNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value);
775 smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value);
776 smallArrayt* injectNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string);
777 smallArrayt* injectNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict);
778 smallArrayt* injectNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array);
779 smallArrayt* injectNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array);
780 smallArrayt* injectNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value);
781 smallArrayt* injectNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value);
782 smallArrayt* injectNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value);
783 smallArrayt* injectNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value);
784 smallArrayt* injectNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string);
785 smallArrayt* injectNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string);
786 smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
787 smallArrayt* delSmallArrayG (smallArrayt *self, int64_t start, int64_t end);
788 smallArrayt* delElemSmallArrayG (smallArrayt *self, int64_t index);
789 smallArrayt* removeSmallArrayG (smallArrayt *self, int64_t start, int64_t end);
790 smallArrayt* removeElemSmallArrayG (smallArrayt *self, int64_t index);
791 smallArrayt* sortSmallArrayG (smallArrayt *self);
792 smallArrayt* sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction);
793 smallArrayt* icSortSmallArrayG (smallArrayt *self);
794 bool equalSmallArrayG (smallArrayt *self, smallArrayt *array);
795 bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array);
796 bool equalSmallArrayArrayG(smallArrayt* self, char ** p2);
797 bool equalSmallArrayCArrayG(smallArrayt* self, const char ** p2);
798 bool equalSmallArrayBaseG(smallArrayt* self, baset* p2);
799 bool icEqualSmallArrayG (smallArrayt *self, smallArrayt *array);
800 bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array);
801 bool icEqualSmallArrayArrayG(smallArrayt* self, char ** p2);
802 bool icEqualSmallArrayCArrayG(smallArrayt* self, const char ** p2);
803 bool icEqualSmallArrayBaseG(smallArrayt* self, baset* p2);
804 size_t lenSmallArrayG (smallArrayt *self);
805 smallArrayt* trimSmallArrayG (smallArrayt *self);
806 bool hasSmallArrayG (smallArrayt *self, baset *value);
807 bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value);
808 bool hasBoolSmallArrayG (smallArrayt *self, bool value);
809 bool hasDoubleSmallArrayG (smallArrayt *self, double value);
810 bool hasIntSmallArrayG (smallArrayt *self, int64_t value);
811 bool hasSSmallArrayG (smallArrayt *self, const char *string);
812 bool hasCharSmallArrayG(smallArrayt *self, char c);
813 bool hasDictSmallArrayG (smallArrayt *self, smallDictt *dict);
814 bool hasArraySmallArrayG (smallArrayt *self, smallArrayt *array);
815 bool hasArraycSmallArrayG (smallArrayt *self, char **array);
816 bool hasCArraycSmallArrayG (smallArrayt *self, const char **array);
817 bool hasSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
818 bool hasSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
819 bool hasSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
820 bool hasSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
821 bool hasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
822 bool hasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
823 bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
824 ssize_t indexOfSmallArrayG (smallArrayt *self, baset *value);
825 ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value);
826 ssize_t indexOfBoolSmallArrayG (smallArrayt *self, bool value);
827 ssize_t indexOfDoubleSmallArrayG (smallArrayt *self, double value);
828 ssize_t indexOfIntSmallArrayG (smallArrayt *self, int64_t value);
829 ssize_t indexOfSSmallArrayG (smallArrayt *self, const char *string);
830 ssize_t indexOfCharSmallArrayG(smallArrayt *self, char c);
831 ssize_t indexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict);
832 ssize_t indexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array);
833 ssize_t indexOfArraycSmallArrayG (smallArrayt *self, char **array);
834 ssize_t indexOfCArraycSmallArrayG (smallArrayt *self, const char **array);
835 ssize_t indexOfSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
836 ssize_t indexOfSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
837 ssize_t indexOfSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
838 ssize_t indexOfSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
839 ssize_t indexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
840 ssize_t indexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
841 ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
842 ssize_t binarySearchSmallArrayG (smallArrayt *self, baset *value);
843 ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value);
844 ssize_t binarySearchBoolSmallArrayG (smallArrayt *self, bool value);
845 ssize_t binarySearchDoubleSmallArrayG (smallArrayt *self, double value);
846 ssize_t binarySearchIntSmallArrayG (smallArrayt *self, int64_t value);
847 ssize_t binarySearchSSmallArrayG (smallArrayt *self, const char *string);
848 ssize_t binarySearchCharSmallArrayG(smallArrayt *self, char c);
849 ssize_t binarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict);
850 ssize_t binarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array);
851 ssize_t binarySearchArraycSmallArrayG (smallArrayt *self, char **array);
852 ssize_t binarySearchCArraycSmallArrayG (smallArrayt *self, const char **array);
853 ssize_t binarySearchSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value);
854 ssize_t binarySearchSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value);
855 ssize_t binarySearchSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value);
856 ssize_t binarySearchSmallIntSmallArrayG (smallArrayt *self, smallIntt *value);
857 ssize_t binarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
858 ssize_t binarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
859 ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container);
860 smallArrayt* uniqSmallArrayG(smallArrayt *self, int dum UNUSED);
861 bool icHasSmallArrayG (smallArrayt *self, baset *value);
862 bool icHasSSmallArrayG (smallArrayt *self, const char *string);
863 bool icHasCharSmallArrayG(smallArrayt *self, char c);
864 bool icHasDictSmallArrayG (smallArrayt *self, smallDictt *dict);
865 bool icHasArraySmallArrayG (smallArrayt *self, smallArrayt *array);
866 bool icHasArraycSmallArrayG (smallArrayt *self, char **array);
867 bool icHasCArraycSmallArrayG (smallArrayt *self, const char **array);
868 bool icHasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
869 bool icHasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
870 ssize_t icIndexOfSmallArrayG (smallArrayt *self, baset *value);
871 ssize_t icIndexOfSSmallArrayG (smallArrayt *self, const char *string);
872 ssize_t icIndexOfCharSmallArrayG(smallArrayt *self, char c);
873 ssize_t icIndexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict);
874 ssize_t icIndexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array);
875 ssize_t icIndexOfArraycSmallArrayG (smallArrayt *self, char **array);
876 ssize_t icIndexOfCArraycSmallArrayG (smallArrayt *self, const char **array);
877 ssize_t icIndexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
878 ssize_t icIndexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
879 ssize_t icBinarySearchSmallArrayG (smallArrayt *self, baset *value);
880 ssize_t icBinarySearchSSmallArrayG (smallArrayt *self, const char *string);
881 ssize_t icBinarySearchCharSmallArrayG(smallArrayt *self, char c);
882 ssize_t icBinarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict);
883 ssize_t icBinarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array);
884 ssize_t icBinarySearchArraycSmallArrayG (smallArrayt *self, char **array);
885 ssize_t icBinarySearchCArraycSmallArrayG (smallArrayt *self, const char **array);
886 ssize_t icBinarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string);
887 ssize_t icBinarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string);
888 smallArrayt* icUniqSmallArrayG(smallArrayt *self, int dum UNUSED);
889 smallArrayt* compactSmallArrayG (smallArrayt *self);
890 smallArrayt* emptySmallArrayG (smallArrayt *self);
891 bool isEmptySmallArrayG (smallArrayt *self);
892 bool isBlankSmallArrayG (smallArrayt *self);
893 smallStringt* joinSmallArrayG(smallArrayt *self, const char* delim);
894 smallStringt* joinCharSmallArrayG(smallArrayt *self, char c);
895 smallStringt* joinSmallJsonSmallArrayG (smallArrayt *self, smallJsont* delim);
896 smallStringt* joinSmallStringSmallArrayG(smallArrayt *self, smallStringt* delim);
897 char* joinSSmallArrayG(smallArrayt *self, const char* delim);
898 char* joinCharSSmallArrayG(smallArrayt *self, char c);
899 char* joinSmallJsonSSmallArrayG (smallArrayt *self, smallJsont* delim);
900 char* joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt* delim);
901 smallArrayt* zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2);
902 smallArrayt* zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2);
903 smallArrayt* zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2);
904 smallArrayt* zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2);
905 smallArrayt* zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2);
906 smallArrayt* zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2);
907 smallArrayt* zipArraySmallArrayG(smallArrayt *self, char** array1, smallArrayt *array2);
908 smallArrayt* zipCArraySmallArrayG(smallArrayt *self, const char** array1, smallArrayt *array2);
909 smallArrayt* zipArraySmallJsonSmallArrayG(smallArrayt *self, char** array1, smallJsont *array2);
910 smallArrayt* zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char** array1, smallJsont *array2);
911 smallArrayt* zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char** array2);
912 smallArrayt* zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char** array2);
913 smallArrayt* zipArrayCharSmallArrayG(smallArrayt *self, char** array1, char** array2);
914 smallArrayt* zipArrayCCharSmallArrayG(smallArrayt *self, char** array1, const char** array2);
915 smallArrayt* zipCArrayCharSmallArrayG(smallArrayt *self, const char** array1, char** array2);
916 smallArrayt* zipCArrayCCharSmallArrayG(smallArrayt *self, const char** array1, const char** array2);
917 void logSmallArrayG(smallArrayt *self);
918 smallArrayt* readTextSmallArrayG (smallArrayt *self, const char *filePath);
919 smallArrayt* readTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath);
920 smallArrayt* readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
921 smallArrayt* readStreamSmallArrayG (smallArrayt *self, FILE *fp);
922 bool writeTextSmallArrayG (smallArrayt *self, const char *filePath);
923 bool writeTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath);
924 bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
925 bool writeStreamSmallArrayG (smallArrayt *self, FILE *fp);
926 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath);
927 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
928 smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index);
929 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self);
930 
931 void initiateSmallArray(smallArrayt *self) {
932 
933  self->type = "smallArray";
934  if (!smallArrayF) {
935  isError(smallArrayF, malloc(sizeof(smallArrayFunctionst))) {
936  self->f = NULL;
937  return;
938  }
939  registerMethodsSmallArray(smallArrayF);
940  }
941  self->f = smallArrayF;
942 
943  self->a = NULL;
944  self->iterIndex = -1;
945  self->iterStep = 0;
946  self->iterElement = NULL;
947  self->iterElementDataType = 0;
948 }
949 
950 void registerMethodsSmallArray(smallArrayFunctionst *f) {
951 
952  f->free = freeSmallArray;
953  f->terminate = terminateSmallArray;
954  f->toString = toStringSmallArray;
955  f->duplicate = duplicateSmallArray;
956 
957  f->escape = escapeSmallArray;
958  f->dispose = disposeSmallArray;
959  f->reset = resetSmallArray;
960  f->smash = smashSmallArray;
961  f->finish = finishSmallArray;
962  f->help = helpSmallArray;
963  f->getso = getsoSmallArray;
964  f->setso = setsoSmallArray;
965  f->mirror = mirrorSmallArray;
966  f->get = getAtSmallArray;
967  f->getAtUndefined = getAtUndefinedSmallArray;
968  f->getAtBool = getAtBoolSmallArray;
969  f->getAtBoolP = getAtBoolPSmallArray;
970  f->getAtDouble = getAtDoubleSmallArray;
971  f->getAtDoubleP = getAtDoublePSmallArray;
972  f->getAtInt = getAtIntSmallArray;
973  f->getAtIntP = getAtIntPSmallArray;
974  f->getAtInt32 = getAtInt32SmallArray;
975  f->getAtInt32P = getAtInt32PSmallArray;
976  f->getAtUint = getAtUintSmallArray;
977  f->getAtUintP = getAtUintPSmallArray;
978  f->getAtUint32 = getAtUint32SmallArray;
979  f->getAtUint32P = getAtUint32PSmallArray;
980  f->getAtS = getAtSSmallArray;
981  f->getAtDict = getAtDictSmallArray;
982  f->getAtArray = getAtArraySmallArray;
983  f->getAtSmallBool = getAtSmallBoolSmallArray;
984  f->getAtSmallBytes = getAtSmallBytesSmallArray;
985  f->getAtSmallDouble = getAtSmallDoubleSmallArray;
986  f->getAtSmallInt = getAtSmallIntSmallArray;
987  f->getAtSmallJson = getAtSmallJsonSmallArray;
988  f->getAtSmallString = getAtSmallStringSmallArray;
989  f->getAtVoid = getAtVoidSmallArray;
990  f->getAtSmallContainer = getAtSmallContainerSmallArray;
991  f->getNDup = getAtNDupSmallArray;
992  f->getAtNDupUndefined = getAtNDupUndefinedSmallArray;
993  f->getAtNDupBool = getAtNDupBoolSmallArray;
994  f->getAtNDupDouble = getAtNDupDoubleSmallArray;
995  f->getAtNDupInt = getAtNDupIntSmallArray;
996  f->getAtNDupInt32 = getAtNDupInt32SmallArray;
997  f->getAtNDupUint = getAtNDupUintSmallArray;
998  f->getAtNDupUint32 = getAtNDupUint32SmallArray;
999  f->getAtNDupS = getAtNDupSSmallArray;
1000  f->getAtNDupDict = getAtNDupDictSmallArray;
1001  f->getAtNDupArray = getAtNDupArraySmallArray;
1002  f->getAtNDupSmallBool = getAtNDupSmallBoolSmallArray;
1003  f->getAtNDupSmallBytes = getAtNDupSmallBytesSmallArray;
1004  f->getAtNDupSmallDouble = getAtNDupSmallDoubleSmallArray;
1005  f->getAtNDupSmallInt = getAtNDupSmallIntSmallArray;
1006  f->getAtNDupSmallJson = getAtNDupSmallJsonSmallArray;
1007  f->getAtNDupSmallString = getAtNDupSmallStringSmallArray;
1008  f->getAtNDupVoid = getAtNDupVoidSmallArray;
1009  f->getAtNDupSmallContainer = getAtNDupSmallContainerSmallArray;
1010  f->set = setAtSmallArray;
1011  f->fromArray = fromArraySmallArray;
1012  f->fromCArray = fromCArraySmallArray;
1013  f->fromArrayNFree = fromArrayNFreeSmallArray;
1014  f->push = pushSmallArray;
1015  f->pushUndefined = pushUndefinedSmallArray;
1016  f->pushBool = pushBoolSmallArray;
1017  f->pushDouble = pushDoubleSmallArray;
1018  f->pushInt = pushIntSmallArray;
1019  f->pushS = pushSSmallArray;
1020  f->pushChar = pushCharSmallArray;
1021  f->pushDict = pushDictSmallArray;
1022  f->pushArray = pushArraySmallArray;
1023  f->pushArrayc = pushArraycSmallArray;
1024  f->pushCArrayc = pushCArraycSmallArray;
1025  f->pushSmallBool = pushSmallBoolSmallArray;
1026  f->pushSmallBytes = pushSmallBytesSmallArray;
1027  f->pushSmallDouble = pushSmallDoubleSmallArray;
1028  f->pushSmallInt = pushSmallIntSmallArray;
1029  f->pushSmallJson = pushSmallJsonSmallArray;
1030  f->pushSmallString = pushSmallStringSmallArray;
1031  f->pushSmallContainer = pushSmallContainerSmallArray;
1032  f->pushNFree = pushNFreeSmallArray;
1033  f->pushNFreeUndefined = pushNFreeUndefinedSmallArray;
1034  f->pushNFreeS = pushNFreeSSmallArray;
1035  f->pushNFreeDict = pushNFreeDictSmallArray;
1036  f->pushNFreeArray = pushNFreeArraySmallArray;
1037  f->pushNFreeArrayc = pushNFreeArraycSmallArray;
1038  f->pushNFreeSmallBool = pushNFreeSmallBoolSmallArray;
1039  f->pushNFreeSmallBytes = pushNFreeSmallBytesSmallArray;
1040  f->pushNFreeSmallDouble = pushNFreeSmallDoubleSmallArray;
1041  f->pushNFreeSmallInt = pushNFreeSmallIntSmallArray;
1042  f->pushNFreeSmallJson = pushNFreeSmallJsonSmallArray;
1043  f->pushNFreeSmallString = pushNFreeSmallStringSmallArray;
1044  f->pushNFreeSmallContainer = pushNFreeSmallContainerSmallArray;
1045  f->pushMany = pushManySmallArray;
1046  f->pushManyS = pushManySSmallArray;
1047  f->pushNFreeMany = pushNFreeManySmallArray;
1048  f->pushNFreeManyS = pushNFreeManySSmallArray;
1049  f->pop = popSmallArray;
1050  f->popUndefined = popUndefinedSmallArray;
1051  f->popBool = popBoolSmallArray;
1052  f->popDouble = popDoubleSmallArray;
1053  f->popInt = popIntSmallArray;
1054  f->popInt32 = popInt32SmallArray;
1055  f->popUint = popUintSmallArray;
1056  f->popUint32 = popUint32SmallArray;
1057  f->popS = popSSmallArray;
1058  f->popDict = popDictSmallArray;
1059  f->popArray = popArraySmallArray;
1060  f->popSmallBool = popSmallBoolSmallArray;
1061  f->popSmallBytes = popSmallBytesSmallArray;
1062  f->popSmallDouble = popSmallDoubleSmallArray;
1063  f->popSmallInt = popSmallIntSmallArray;
1064  f->popSmallJson = popSmallJsonSmallArray;
1065  f->popSmallString = popSmallStringSmallArray;
1066  f->popVoid = popVoidSmallArray;
1067  f->popSmallContainer = popSmallContainerSmallArray;
1068  f->popNum = popNumSmallArray;
1069  f->prepend = prependSmallArray;
1070  f->prependUndefined = prependUndefinedSmallArray;
1071  f->prependBool = prependBoolSmallArray;
1072  f->prependDouble = prependDoubleSmallArray;
1073  f->prependInt = prependIntSmallArray;
1074  f->prependS = prependSSmallArray;
1075  f->prependChar = prependCharSmallArray;
1076  f->prependDict = prependDictSmallArray;
1077  f->prependArray = prependArraySmallArray;
1078  f->prependArrayc = prependArraycSmallArray;
1079  f->prependCArrayc = prependCArraycSmallArray;
1080  f->prependSmallBool = prependSmallBoolSmallArray;
1081  f->prependSmallBytes = prependSmallBytesSmallArray;
1082  f->prependSmallDouble = prependSmallDoubleSmallArray;
1083  f->prependSmallInt = prependSmallIntSmallArray;
1084  f->prependSmallJson = prependSmallJsonSmallArray;
1085  f->prependSmallString = prependSmallStringSmallArray;
1086  f->prependSmallContainer = prependSmallContainerSmallArray;
1087  f->prependNFree = prependNFreeSmallArray;
1088  f->prependNFreeUndefined = prependNFreeUndefinedSmallArray;
1089  f->prependNFreeS = prependNFreeSSmallArray;
1090  f->prependNFreeDict = prependNFreeDictSmallArray;
1091  f->prependNFreeArray = prependNFreeArraySmallArray;
1092  f->prependNFreeArrayc = prependNFreeArraycSmallArray;
1093  f->prependNFreeSmallBool = prependNFreeSmallBoolSmallArray;
1094  f->prependNFreeSmallBytes = prependNFreeSmallBytesSmallArray;
1095  f->prependNFreeSmallDouble = prependNFreeSmallDoubleSmallArray;
1096  f->prependNFreeSmallInt = prependNFreeSmallIntSmallArray;
1097  f->prependNFreeSmallJson = prependNFreeSmallJsonSmallArray;
1098  f->prependNFreeSmallString = prependNFreeSmallStringSmallArray;
1099  f->prependNFreeSmallContainer = prependNFreeSmallContainerSmallArray;
1100  f->dequeue = dequeueSmallArray;
1101  f->dequeueUndefined = dequeueUndefinedSmallArray;
1102  f->dequeueBool = dequeueBoolSmallArray;
1103  f->dequeueDouble = dequeueDoubleSmallArray;
1104  f->dequeueInt = dequeueIntSmallArray;
1105  f->dequeueInt32 = dequeueInt32SmallArray;
1106  f->dequeueUint = dequeueUintSmallArray;
1107  f->dequeueUint32 = dequeueUint32SmallArray;
1108  f->dequeueS = dequeueSSmallArray;
1109  f->dequeueDict = dequeueDictSmallArray;
1110  f->dequeueArray = dequeueArraySmallArray;
1111  f->dequeueSmallBool = dequeueSmallBoolSmallArray;
1112  f->dequeueSmallBytes = dequeueSmallBytesSmallArray;
1113  f->dequeueSmallDouble = dequeueSmallDoubleSmallArray;
1114  f->dequeueSmallInt = dequeueSmallIntSmallArray;
1115  f->dequeueSmallJson = dequeueSmallJsonSmallArray;
1116  f->dequeueSmallString = dequeueSmallStringSmallArray;
1117  f->dequeueVoid = dequeueVoidSmallArray;
1118  f->dequeueSmallContainer = dequeueSmallContainerSmallArray;
1119  f->dequeueNum = dequeueNumSmallArray;
1120  f->reverse = reverseSmallArray;
1121  f->cat = catSmallArray;
1122  f->append = appendSmallArray;
1123  f->appendSmallJson = appendSmallJsonSmallArray;
1124  f->appendNSmash = appendNSmashSmallArray;
1125  f->appendNSmashSmallJson = appendNSmashSmallJsonSmallArray;
1126  f->appendArray = appendArraySmallArray;
1127  f->appendCArray = appendCArraySmallArray;
1128  f->appendNSmashArray = appendNSmashArraySmallArray;
1129  f->shift = shiftSmallArray; {
1130  f->shiftSmallJson = shiftSmallJsonSmallArray; {
1131  f->shiftNSmash = shiftNSmashSmallArray; {
1132  f->shiftNSmashSmallJson = shiftNSmashSmallJsonSmallArray; {
1133  f->add = addSmallArray;
1134  f->slice = sliceSmallArray;
1135  f->crop = cropSmallArray;
1136  f->cropElem = cropElemSmallArray;
1137  f->cropElemUndefined = cropElemUndefinedSmallArray;
1138  f->cropElemBool = cropElemBoolSmallArray;
1139  f->cropElemDouble = cropElemDoubleSmallArray;
1140  f->cropElemInt = cropElemIntSmallArray;
1141  f->cropElemInt32 = cropElemInt32SmallArray;
1142  f->cropElemUint = cropElemUintSmallArray;
1143  f->cropElemUint32 = cropElemUint32SmallArray;
1144  f->cropElemS = cropElemSSmallArray;
1145  f->cropElemDict = cropElemDictSmallArray;
1146  f->cropElemArray = cropElemArraySmallArray;
1147  f->cropElemSmallBool = cropElemSmallBoolSmallArray;
1148  f->cropElemSmallBytes = cropElemSmallBytesSmallArray;
1149  f->cropElemSmallDouble = cropElemSmallDoubleSmallArray;
1150  f->cropElemSmallInt = cropElemSmallIntSmallArray;
1151  f->cropElemSmallJson = cropElemSmallJsonSmallArray;
1152  f->cropElemSmallString = cropElemSmallStringSmallArray;
1153  f->cropElemVoid = cropElemVoidSmallArray;
1154  f->cropElemSmallContainer = cropElemSmallContainerSmallArray;
1155  f->copy = copySmallArray;
1156  f->insert = insertSmallArray;
1157  f->insertSmallJson = insertSmallJsonSmallArray;
1158  f->insertNSmash = insertNSmashSmallArray;
1159  f->insertNSmashSmallJson = insertNSmashSmallJsonSmallArray;
1160  f->inject = injectSmallArray;
1161  f->injectUndefined = injectUndefinedSmallArray;
1162  f->injectBool = injectBoolSmallArray;
1163  f->injectDouble = injectDoubleSmallArray;
1164  f->injectInt = injectIntSmallArray;
1165  f->injectS = injectSSmallArray;
1166  f->injectChar = injectCharSmallArray;
1167  f->injectDict = injectDictSmallArray;
1168  f->injectArray = injectArraySmallArray;
1169  f->injectArrayc = injectArraycSmallArray;
1170  f->injectCArrayc = injectCArraycSmallArray;
1171  f->injectSmallBool = injectSmallBoolSmallArray;
1172  f->injectSmallBytes = injectSmallBytesSmallArray;
1173  f->injectSmallDouble = injectSmallDoubleSmallArray;
1174  f->injectSmallInt = injectSmallIntSmallArray;
1175  f->injectSmallJson = injectSmallJsonSmallArray;
1176  f->injectSmallString = injectSmallStringSmallArray;
1177  f->injectSmallContainer = injectSmallContainerSmallArray;
1178  f->injectNFree = injectNFreeSmallArray;
1179  f->injectNFreeUndefined = injectNFreeUndefinedSmallArray;
1180  f->injectNFreeS = injectNFreeSSmallArray;
1181  f->injectNFreeDict = injectNFreeDictSmallArray;
1182  f->injectNFreeArray = injectNFreeArraySmallArray;
1183  f->injectNFreeArrayc = injectNFreeArraycSmallArray;
1184  f->injectNFreeSmallBool = injectNFreeSmallBoolSmallArray;
1185  f->injectNFreeSmallBytes = injectNFreeSmallBytesSmallArray;
1186  f->injectNFreeSmallDouble = injectNFreeSmallDoubleSmallArray;
1187  f->injectNFreeSmallInt = injectNFreeSmallIntSmallArray;
1188  f->injectNFreeSmallJson = injectNFreeSmallJsonSmallArray;
1189  f->injectNFreeSmallString = injectNFreeSmallStringSmallArray;
1190  f->injectNFreeSmallContainer = injectNFreeSmallContainerSmallArray;
1191  f->del = delSmallArray;
1192  f->delElem = delElemSmallArray;
1193  f->remove = removeSmallArray;
1194  f->removeElem = removeElemSmallArray;
1195  f->sort = sortSmallArray;
1196  f->sortF = sortFSmallArray;
1197  f->icSort = icSortSmallArray;
1198  f->equal = equalSmallArray;
1199  f->equalSmallJson = equalSmallArraySmallJson;
1200  f->equalArray = equalSmallArrayArray;
1201  f->equalCArray = equalSmallArrayCArray;
1202  f->equalBase = equalSmallArrayBase;
1203  f->icEqual = icEqualSmallArray;
1204  f->icEqualSmallJson = icEqualSmallArraySmallJson;
1205  f->icEqualArray = icEqualSmallArrayArray;
1206  f->icEqualCArray = icEqualSmallArrayCArray;
1207  f->icEqualBase = icEqualSmallArrayBase;
1208  f->len = lenSmallArray;
1209  f->trim = trimSmallArray;
1210  f->getAt = getAtSmallArray;
1211  f->getAtNDup = getAtNDupSmallArray;
1212  f->setAt = setAtSmallArray;
1213  f->setAtUndefined = setAtUndefinedSmallArray;
1214  f->setAtBool = setAtBoolSmallArray;
1215  f->setAtDouble = setAtDoubleSmallArray;
1216  f->setAtInt = setAtIntSmallArray;
1217  f->setAtS = setAtSSmallArray;
1218  f->setAtChar = setAtCharSmallArray;
1219  f->setAtDict = setAtDictSmallArray;
1220  f->setAtArray = setAtArraySmallArray;
1221  f->setAtArrayc = setAtArraycSmallArray;
1222  f->setAtCArrayc = setAtCArraycSmallArray;
1223  f->setAtSmallBool = setAtSmallBoolSmallArray;
1224  f->setAtSmallBytes = setAtSmallBytesSmallArray;
1225  f->setAtSmallDouble = setAtSmallDoubleSmallArray;
1226  f->setAtSmallInt = setAtSmallIntSmallArray;
1227  f->setAtSmallJson = setAtSmallJsonSmallArray;
1228  f->setAtSmallString = setAtSmallStringSmallArray;
1229  f->setAtSmallContainer = setAtSmallContainerSmallArray;
1230  f->setAtNFree = setAtNFreeSmallArray;
1231  f->setAtNFreeUndefined = setAtNFreeUndefinedSmallArray;
1232  f->setAtNFreeS = setAtNFreeSSmallArray;
1233  f->setAtNFreeDict = setAtNFreeDictSmallArray;
1234  f->setAtNFreeArray = setAtNFreeArraySmallArray;
1235  f->setAtNFreeArrayc = setAtNFreeArraycSmallArray;
1236  f->setAtNFreeSmallBool = setAtNFreeSmallBoolSmallArray;
1237  f->setAtNFreeSmallBytes = setAtNFreeSmallBytesSmallArray;
1238  f->setAtNFreeSmallDouble = setAtNFreeSmallDoubleSmallArray;
1239  f->setAtNFreeSmallInt = setAtNFreeSmallIntSmallArray;
1240  f->setAtNFreeSmallJson = setAtNFreeSmallJsonSmallArray;
1241  f->setAtNFreeSmallString = setAtNFreeSmallStringSmallArray;
1242  f->setAtNFreeSmallContainer = setAtNFreeSmallContainerSmallArray;
1243  f->setPAtDict = setPAtDictSmallArray;
1244  f->setPAtArray = setPAtArraySmallArray;
1245  f->setPAtSmallJson = setPAtSmallJsonSmallArray;
1246  f->setPAtSmallString = setPAtSmallStringSmallArray;
1247  f->setPAtNFreeDict = setPAtNFreeDictSmallArray;
1248  f->setPAtNFreeArray = setPAtNFreeArraySmallArray;
1249  f->setPAtNFreeSmallJson = setPAtNFreeSmallJsonSmallArray;
1250  f->setPAtNFreeSmallString = setPAtNFreeSmallStringSmallArray;
1251  f->getNum = getNumSmallArray;
1252  f->has = hasSmallArray;
1253  f->hasUndefined = hasUndefinedSmallArray;
1254  f->hasBool = hasBoolSmallArray;
1255  f->hasDouble = hasDoubleSmallArray;
1256  f->hasInt = hasIntSmallArray;
1257  f->hasS = hasSSmallArray;
1258  f->hasChar = hasCharSmallArray;
1259  f->hasDict = hasDictSmallArray;
1260  f->hasArray = hasArraySmallArray;
1261  f->hasArrayc = hasArraycSmallArray;
1262  f->hasCArrayc = hasCArraycSmallArray;
1263  f->hasSmallBool = hasSmallBoolSmallArray;
1264  f->hasSmallBytes = hasSmallBytesSmallArray;
1265  f->hasSmallDouble = hasSmallDoubleSmallArray;
1266  f->hasSmallInt = hasSmallIntSmallArray;
1267  f->hasSmallJson = hasSmallJsonSmallArray;
1268  f->hasSmallString = hasSmallStringSmallArray;
1269  f->hasSmallContainer = hasSmallContainerSmallArray;
1270  f->indexOf = indexOfSmallArray;
1271  f->indexOfUndefined = indexOfUndefinedSmallArray;
1272  f->indexOfBool = indexOfBoolSmallArray;
1273  f->indexOfDouble = indexOfDoubleSmallArray;
1274  f->indexOfInt = indexOfIntSmallArray;
1275  f->indexOfS = indexOfSSmallArray;
1276  f->indexOfChar = indexOfCharSmallArray;
1277  f->indexOfDict = indexOfDictSmallArray;
1278  f->indexOfArray = indexOfArraySmallArray;
1279  f->indexOfArrayc = indexOfArraycSmallArray;
1280  f->indexOfCArrayc = indexOfCArraycSmallArray;
1281  f->indexOfSmallBool = indexOfSmallBoolSmallArray;
1282  f->indexOfSmallBytes = indexOfSmallBytesSmallArray;
1283  f->indexOfSmallDouble = indexOfSmallDoubleSmallArray;
1284  f->indexOfSmallInt = indexOfSmallIntSmallArray;
1285  f->indexOfSmallJson = indexOfSmallJsonSmallArray;
1286  f->indexOfSmallString = indexOfSmallStringSmallArray;
1287  f->indexOfSmallContainer = indexOfSmallContainerSmallArray;
1288  f->binarySearch = binarySearchSmallArray;
1289  f->binarySearchUndefined = binarySearchUndefinedSmallArray;
1290  f->binarySearchBool = binarySearchBoolSmallArray;
1291  f->binarySearchDouble = binarySearchDoubleSmallArray;
1292  f->binarySearchInt = binarySearchIntSmallArray;
1293  f->binarySearchS = binarySearchSSmallArray;
1294  f->binarySearchChar = binarySearchCharSmallArray;
1295  f->binarySearchDict = binarySearchDictSmallArray;
1296  f->binarySearchArray = binarySearchArraySmallArray;
1297  f->binarySearchArrayc = binarySearchArraycSmallArray;
1298  f->binarySearchCArrayc = binarySearchCArraycSmallArray;
1299  f->binarySearchSmallBool = binarySearchSmallBoolSmallArray;
1300  f->binarySearchSmallBytes = binarySearchSmallBytesSmallArray;
1301  f->binarySearchSmallDouble = binarySearchSmallDoubleSmallArray;
1302  f->binarySearchSmallInt = binarySearchSmallIntSmallArray;
1303  f->binarySearchSmallJson = binarySearchSmallJsonSmallArray;
1304  f->binarySearchSmallString = binarySearchSmallStringSmallArray;
1305  f->binarySearchSmallContainer = binarySearchSmallContainerSmallArray;
1306  f->uniq = uniqSmallArray;
1307  f->icHas = icHasSmallArray;
1308  f->icHasS = icHasSSmallArray;
1309  f->icHasChar = icHasCharSmallArray;
1310  f->icHasDict = icHasDictSmallArray;
1311  f->icHasArray = icHasArraySmallArray;
1312  f->icHasArrayc = icHasArraycSmallArray;
1313  f->icHasCArrayc = icHasCArraycSmallArray;
1314  f->icHasSmallJson = icHasSmallJsonSmallArray;
1315  f->icHasSmallString = icHasSmallStringSmallArray;
1316  f->icIndexOf = icIndexOfSmallArray;
1317  f->icIndexOfS = icIndexOfSSmallArray;
1318  f->icIndexOfChar = icIndexOfCharSmallArray;
1319  f->icIndexOfDict = icIndexOfDictSmallArray;
1320  f->icIndexOfArray = icIndexOfArraySmallArray;
1321  f->icIndexOfArrayc = icIndexOfArraycSmallArray;
1322  f->icIndexOfCArrayc = icIndexOfCArraycSmallArray;
1323  f->icIndexOfSmallJson = icIndexOfSmallJsonSmallArray;
1324  f->icIndexOfSmallString = icIndexOfSmallStringSmallArray;
1325  f->icBinarySearch = icBinarySearchSmallArray;
1326  f->icBinarySearchS = icBinarySearchSSmallArray;
1327  f->icBinarySearchChar = icBinarySearchCharSmallArray;
1328  f->icBinarySearchDict = icBinarySearchDictSmallArray;
1329  f->icBinarySearchArray = icBinarySearchArraySmallArray;
1330  f->icBinarySearchArrayc = icBinarySearchArraycSmallArray;
1331  f->icBinarySearchCArrayc = icBinarySearchCArraycSmallArray;
1332  f->icBinarySearchSmallJson = icBinarySearchSmallJsonSmallArray;
1333  f->icBinarySearchSmallString = icBinarySearchSmallStringSmallArray;
1334  f->icUniq = icUniqSmallArray;
1335  f->compact = compactSmallArray;
1336  f->empty = emptySmallArray;
1337  f->isEmpty = isEmptySmallArray;
1338  f->isBlank = isBlankSmallArray;
1339  f->forEach = forEachSmallArrayF; {
1340  // cg_c bug
1341  f->enumerate = enumerateSmallArrayF; {
1342  f->iterStart = iterStartSmallArray;
1343  f->iterStartLast = iterStartLastSmallArray;
1344  f->iterStartFrom = iterStartFromSmallArray;
1345  f->iterStartFromStep = iterStartFromStepSmallArray;
1346  f->iterNext = iterNextSmallArray;
1347  f->iterElement = iterElementSmallArray;
1348  f->iterIndex = iterIndexSmallArray;
1349  f->iterStep = iterStepSmallArray;
1350  f->join = joinSmallArray;
1351  f->joinChar = joinCharSmallArray;
1352  f->joinSmallJson = joinSmallJsonSmallArray;
1353  f->joinSmallString = joinSmallStringSmallArray;
1354  f->joinS = joinSSmallArray;
1355  f->joinCharS = joinCharSSmallArray;
1356  f->joinSmallJsonS = joinSmallJsonSSmallArray;
1357  f->joinSmallStringS = joinSmallStringSSmallArray;
1358  f->zip = zipSmallArray;
1359  f->zipSmallJson = zipSmallJsonSmallArray;
1360  f->zipSmallJsonSmallArray = zipSmallJsonSmallArraySmallArray;
1361  f->zipSmallJsonSmallJson = zipSmallJsonSmallJsonSmallArray;
1362  f->zipSmallJsonChar = zipSmallJsonCharSmallArray;
1363  f->zipSmallJsonCChar = zipSmallJsonCCharSmallArray;
1364  f->zipArray = zipArraySmallArray;
1365  f->zipCArray = zipCArraySmallArray;
1366  f->zipArraySmallJson = zipArraySmallJsonSmallArray;
1367  f->zipCArraySmallJson = zipCArraySmallJsonSmallArray;
1368  f->zipChar = zipCharSmallArray;
1369  f->zipCChar = zipCCharSmallArray;
1370  f->zipArrayChar = zipArrayCharSmallArray;
1371  f->zipCArrayChar = zipCArrayCharSmallArray;
1372  f->zipArrayCChar = zipArrayCCharSmallArray;
1373  f->zipCArrayCChar = zipCArrayCCharSmallArray;
1374  f->log = logSmallArray;
1375  f->readText = readTextSmallArray;
1376  f->readTextSmallJson = readTextSmallJsonSmallArray;
1377  f->readTextSmallString = readTextSmallStringSmallArray;
1378  f->readStream = readStreamSmallArray;
1379  f->writeText = writeTextSmallArray;
1380  f->writeTextSmallJson = writeTextSmallJsonSmallArray;
1381  f->writeTextSmallString = writeTextSmallStringSmallArray;
1382  f->writeStream = writeStreamSmallArray;
1383  f->appendText = appendTextSmallArray;
1384  f->appendTextSmallString = appendTextSmallStringSmallArray;
1385  f->typeString = typeStringSmallArray;
1386  f->typeSmallString = typeSmallStringSmallArray;
1387  f->type = typeSmallArray;
1388  f->typeStrings = typeStringsSmallArray;
1389  f->typeSmallStrings = typeSmallStringsSmallArray;
1390  f->types = typesSmallArray;
1391  f->isEType = isETypeSmallArray;
1392  f->isEUndefined = isEUndefinedSmallArray;
1393  f->isEBool = isEBoolSmallArray;
1394  f->isEContainer = isEContainerSmallArray;
1395  f->isEDict = isEDictSmallArray;
1396  f->isEDouble = isEDoubleSmallArray;
1397  f->isEInt = isEIntSmallArray;
1398  f->isEString = isEStringSmallArray;
1399  f->isEFaststring = isEFaststringSmallArray;
1400  f->isEArray = isEArraySmallArray;
1401  f->isEBytes = isEBytesSmallArray;
1402  f->areAllEType = areAllETypeSmallArray;
1403  f->areAllEUndefined = areAllEUndefinedSmallArray;
1404  f->areAllEBool = areAllEBoolSmallArray;
1405  f->areAllEContainer = areAllEContainerSmallArray;
1406  f->areAllEDict = areAllEDictSmallArray;
1407  f->areAllEDouble = areAllEDoubleSmallArray;
1408  f->areAllEInt = areAllEIntSmallArray;
1409  f->areAllEString = areAllEStringSmallArray;
1410  f->areAllEFaststring = areAllEFaststringSmallArray;
1411  f->areAllEArray = areAllEArraySmallArray;
1412  f->areAllEBytes = areAllEBytesSmallArray;
1413 }
1414  }
1415  }
1416  }
1417  }
1418  }
1419  }
1420 
1421 void initiateAllocateSmallArray(smallArrayt **self) {
1422 
1423  if (self) {
1424  #if (recycleContainers)
1425  initAllocateRecycle(smallArrayt);
1426  #else
1427  isError(*self, malloc(sizeof(smallArrayt)))
1428  return;
1429  #endif
1430  // recycleContainers
1431  if (*self) {
1432  initiateSmallArray(*self);
1433  if (!(*self)->f) {
1434  finishSmallArray(self);
1435 }
1436  }
1437  }
1438  }
1439 
1440 smallArrayt* allocSmallArray(void) {
1441  smallArrayt *r = NULL;
1442 
1443  initiateAllocateSmallArray(&r);
1444  return(r);
1445 }
1446 
1447 smallArrayt* allocArraySmallArray(char **array) {
1448  smallArrayt *r = NULL;
1449 
1450  isError(r, allocSmallArray()) return(NULL);
1451  fromArraySmallArray(r, array, 0);
1452  return(r);
1453 }
1454 
1455 smallArrayt* allocCArraySmallArray(const char **array) {
1456  smallArrayt *r = NULL;
1457 
1458  isError(r, allocSmallArray()) return(NULL);
1459  fromCArraySmallArray(r, array, 0);
1460  return(r);
1461 }
1462 
1463 void cleanUpSmallArrayTerminateG(smallArrayt **val) {
1464 
1465  terminateO(*val);
1466 }
1467 
1468 void cleanUpSmallArrayFreeLocalG(smallArrayt *val) {
1469 
1470  freeO(val);
1471 }
1472 
1473 void cleanUpSmallArrayFreeG(smallArrayt **val) {
1474 
1475  freeO(*val);
1476 }
1477 
1478 void cleanUpSmallArrayFinishG(smallArrayt **val) {
1479 
1480  finishO(*val);
1481 }
1482 
1483 void cleanUpSmallArrayDisposeG(smallArrayt *val) {
1484 
1485  disposeO(val);
1486 }
1487 
1488 void cleanUpSmallArraySmashG(smallArrayt **val) {
1489 
1490  smashO(*val);
1491 }
1492 
1493 smallArrayt* createSAF(const char *paramType, ...) {
1494  va_list pl;
1495  smallArrayt *r = NULL;
1496 
1497  isError(r, allocSmallArray()) return(NULL);
1498 
1499  // push arguments to a list
1500  va_start(pl, paramType);
1501  paramType = va_arg(pl, const char *);
1502  while (paramType) {
1503  pushSSmallArray(r, paramType);
1504  paramType = va_arg(pl, const char *);
1505  }
1506  va_end(pl);
1507  return(r);
1508 }
1509 
1510 void finalizeRecycleSmallArray(void *arg UNUSED) {
1511 
1512  #if (recycleContainers)
1513  finalizeRecycle
1514  #endif
1515  // recycleContainers
1516 }
1517 
1518 void finalizeSmallArray(void) {
1519 
1520  if (smallArrayF) {
1521  free(smallArrayF);
1522  smallArrayF = NULL;
1523  }
1524  finalizeRecycleSmallArray(NULL);
1525 }
1526 
1527 internal void freeSmallArray(smallArrayt *self) {
1528 
1529  sFree((smallt *)self->a);
1530  resetSmallArray(self);
1531 }
1532 
1533 internal void terminateSmallArray(smallArrayt **self) {
1534 
1535  freeSmallArray(*self);
1536  finishSmallArray(self);
1537 }
1538 
1539 
1540 internal char* toStringSmallArray(smallArrayt *self) {
1541 
1542  if (!self->a) {
1543  return(strdup("[]"));
1544  }
1545  return(sToString((smallt *)self->a));
1546 }
1547 
1548 internal smallArrayt* duplicateSmallArray(smallArrayt *self) {
1549 
1550  createAllocateSmallArray(dup);
1551  if (!dup) {
1552  return(NULL);
1553  }
1554  dup->iterElementDataType = self->iterElementDataType;
1555  if (self->a) {
1556  forEachSArray(self->a, o) {
1557  if (o) {
1558  sArrayPushTiny(&(dup->a), sDuplicateTiny(o));
1559  }
1560  }
1561 
1562  dup->iterIndex = self->iterIndex;
1563  dup->iterStep = self->iterStep;
1564  if (dup->iterIndex != -1) {
1565  dup->iterElement = toBaset(sArrayGetTiny(dup->a, (uint32_t)dup->iterIndex));
1566  }
1567  }
1568  return(dup);
1569 }
1570 
1571 internal char* escapeSmallArray(smallArrayt *self) {
1572 
1573  if (!self->a) {
1574  return(strdup("[]"));
1575  }
1576  return(sEscape((smallt *)self->a));
1577 }
1578 
1579 internal void disposeSmallArray(smallArrayt *self) {
1580 
1581  if (self->a) {
1582  // free containers of baset object to avoid leaks
1583  forEachSArray(self->a, o) {
1584  if (o && o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET)) {
1585  free(o);
1586  }
1587  }
1588  free(self->a);
1589  resetSmallArray(self);
1590 }
1591  }
1592 
1593 internal void smashSmallArray(smallArrayt **self) {
1594 
1595  disposeSmallArray(*self);
1596  finishSmallArray(self);
1597 }
1598 
1599 #if (NFreeStackCheck)
1600 internal void finishSmallArray(smallArrayt **self) {
1601 
1602  resetSmallArray(*self);
1603 
1604  register u64 rsp asm("rsp");
1605  if ((u64)*self > rsp) {
1606  logW("Probably trying to free a smallArray on stack: "BLD PRIx64 RST" sp: "BLD PRIx64 RST, *self, rsp);
1607  logBtrace;
1608  }
1609  else {
1610  #if (recycleContainers)
1611  finishRecycle
1612  #else
1613  free(*self);
1614  #endif
1615  // recycleContainers
1616  *self = NULL;
1617 }
1618  }
1619 
1620 #else
1621 // #if NFreeStackCheck
1622 internal void finishSmallArray(smallArrayt **self) {
1623 
1624  resetSmallArray(*self);
1625 
1626  #if (recycleContainers)
1627  finishRecycle
1628  #else
1629  free(*self);
1630  #endif
1631  // recycleContainers
1632  *self = NULL;
1633 }
1634 
1635 #endif
1636 // #if NFreeStackCheck
1637 
1638 internal const char* helpSmallArray(smallArrayt UNUSED *self) {
1639 
1640  return(helpTextSmallArray);
1641 }
1642 
1643 internal void resetSmallArray(smallArrayt *self) {
1644 
1645  if (self->iterIndex != -1) {
1646  if (self->iterElementDataType != SH_DT_BASET) {
1647  finishO(self->iterElement);
1648  }
1649  self->iterElement = NULL;
1650  self->iterIndex = -1;
1651  }
1652  self->a = NULL;
1653 }
1654 
1655 internal sArrayt* getsoSmallArray(smallArrayt *self) {
1656 
1657  return(self->a);
1658 }
1659 
1660 internal void setsoSmallArray(smallArrayt *self, sArrayt *so) {
1661 
1662  resetSmallArray(self);
1663  self->a = so;
1664 }
1665 
1666 internal smallArrayt* mirrorSmallArray(smallArrayt *self) {
1667 
1668  createAllocateSmallArray(mirror);
1669  if (!mirror) {
1670  return(NULL);
1671  }
1672 
1673  if (!self->a) {
1674  // empty Array
1675  return(mirror);
1676  }
1677 
1678  mirror->a = self->a;
1679 
1680  mirror->iterElementDataType = self->iterElementDataType;
1681  mirror->iterIndex = self->iterIndex;
1682  mirror->iterStep = self->iterStep;
1683  if (mirror->iterIndex != -1) {
1684  mirror->iterElement = toBaset(sArrayGetTiny(mirror->a, (uint32_t)mirror->iterIndex));
1685  }
1686  return(mirror);
1687 }
1688 
1689 
1690 // size 0 means NULL terminated array
1691 internal smallArrayt* fromArraySmallArray(smallArrayt *self, char **array, size_t size) {
1692 
1693  // sanity checks
1694  if (!array) {
1695  return(NULL);
1696  }
1697 
1698  freeSmallArray(self);
1699 
1700  if (!size) {
1701  forEachCharP(array, e) {
1702  sStringt *s = allocSStringTiny(*e);
1703  if (!s) {
1704  return(NULL);
1705  }
1706  sArrayPushTiny(&(self->a), (smallt *) s);
1707  }
1708  return(self);
1709  }
1710 
1711  // copy array content
1712  for (size_t i = 0 ; i < size ; i++) {
1713  if (array[i]) {
1714  // remove NULL strings
1715  sStringt *s = allocSStringTiny(array[i]);
1716  if (!s) {
1717  return(NULL);
1718  }
1719  sArrayPushTiny(&(self->a), (smallt *) s);
1720  }
1721  else {
1722  sArrayPushTiny(&(self->a), NULL);
1723  }
1724  }
1725 
1726  return(self);
1727 }
1728 
1729 internal smallArrayt* fromCArraySmallArray(smallArrayt *self, const char **array, size_t size) {
1730 
1731  // sanity checks
1732  if (!array) {
1733  return(NULL);
1734  }
1735 
1736  freeSmallArray(self);
1737 
1738  if (!size) {
1739  forEachCCharP(array, e) {
1740  sStringt *s = allocSStringTiny(*e);
1741  if (!s) {
1742  return(NULL);
1743  }
1744  sArrayPushTiny(&(self->a), (smallt *) s);
1745  }
1746  return(self);
1747  }
1748 
1749  // copy array content
1750  for (size_t i = 0 ; i < size ; i++) {
1751  if (array[i]) {
1752  // remove NULL strings
1753  sStringt *s = allocSStringTiny(array[i]);
1754  if (!s) {
1755  return(NULL);
1756  }
1757  sArrayPushTiny(&(self->a), (smallt *) s);
1758  }
1759  else {
1760  sArrayPushTiny(&(self->a), NULL);
1761  }
1762  }
1763 
1764  return(self);
1765 }
1766 
1767 internal smallArrayt* fromArrayNFreeSmallArray(smallArrayt *self, char **array, size_t size) {
1768 
1769  smallArrayt *r = fromArraySmallArray(self, array, size);
1770 
1771  if (r) {
1772  if (!size) {
1773  listFreeS(array);
1774  }
1775  else {
1776  for (size_t i = 0 ; i < size ; i++) {
1777  free(array[i]);
1778  }
1779  free(array);
1780  }
1781  }
1782  return(r);
1783 }
1784 
1785 internal smallArrayt* pushSmallArray(smallArrayt *self, baset *value) {
1786  smallt *o = NULL;
1787 
1788  if (!value) {
1789  return(NULL);
1790  }
1791  o = toSmallt(value);;
1792  if (!o) {
1793  return(NULL);
1794  }
1795  sArrayPushTiny(&(self->a), o);
1796  return(self);
1797 }
1798 
1799 internal smallArrayt* pushUndefinedSmallArray(smallArrayt *self) {
1800 
1801  smallt *o = (smallt *) allocSUndefined();
1802  if (!o) {
1803  return(NULL);
1804  }
1805  sArrayPushTiny(&(self->a), o);
1806  return(self);
1807 }
1808 
1809 internal smallArrayt* pushBoolSmallArray(smallArrayt *self, bool value) {
1810 
1811  smallt *o = (smallt *) allocSBool(value);
1812  if (!o) {
1813  return(NULL);
1814  }
1815  sArrayPushTiny(&(self->a), o);
1816  return(self);
1817 }
1818 
1819 internal smallArrayt* pushDoubleSmallArray(smallArrayt *self, double value) {
1820 
1821  smallt *o = (smallt *) allocSDouble(value);
1822  if (!o) {
1823  return(NULL);
1824  }
1825  sArrayPushTiny(&(self->a), o);
1826  return(self);
1827 }
1828 
1829 internal smallArrayt* pushIntSmallArray(smallArrayt *self, int64_t value) {
1830 
1831  smallt *o = (smallt *) allocSInt(value);
1832  if (!o) {
1833  return(NULL);
1834  }
1835  sArrayPushTiny(&(self->a), o);
1836  return(self);
1837 }
1838 
1839 internal smallArrayt* pushSSmallArray(smallArrayt *self, const char *string) {
1840 
1841  smallt *o;
1842  if (!string) {
1843  return(NULL);
1844  }
1845  else {
1846  isError(o, (smallt *) allocSStringTiny(string)) return(NULL);
1847  }
1848  sArrayPushTiny(&(self->a), o);
1849  return(self);
1850 }
1851 
1852 internal smallArrayt* pushCharSmallArray(smallArrayt *self, char c) {
1853 
1854  charToS(s, c);
1855  return(pushSSmallArray(self, s));
1856 }
1857 
1858 internal smallArrayt* pushDictSmallArray(smallArrayt *self, smallDictt *dict) {
1859 
1860  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
1861  return(NULL);
1862  }
1863 
1864  if (!dict) {
1865  return(NULL);
1866  }
1867 
1868  if (!dict->d) {
1869  isError(dict->d, allocSDict()) return(NULL);
1870  }
1871 
1872  sArrayPushTiny(&(self->a), (smallt *)dict->d);
1873  return(self);
1874 }
1875 
1876 
1877 internal smallArrayt* pushArraySmallArray(smallArrayt *self, smallArrayt *array) {
1878 
1879  if (checkObjectTypes && array && !isOSmallArray(array)) {
1880  return(NULL);
1881  }
1882 
1883  if (!array) {
1884  return(NULL);
1885  }
1886 
1887  if (!array->a) {
1888  // allocate empty array
1889  isError(array->a, allocSArray()) return(NULL);
1890  }
1891 
1892  sArrayPushTiny(&(self->a), (smallt *)array->a);
1893  return(self);
1894 }
1895 
1896 internal smallArrayt* pushArraycSmallArray(smallArrayt *self, char **array) {
1897 
1898  // sanity checks
1899  if (!array) {
1900  return(NULL);
1901  }
1902 
1903  sArrayt *a = allocSArray();
1904  if (!a) {
1905  return(NULL);
1906  }
1907 
1908  forEachCharP(array, e) {
1909  sStringt *s = allocSStringTiny(*e);
1910  if (!s) {
1911  return(NULL);
1912  }
1913  sArrayPushTiny(&a, (smallt *) s);
1914  }
1915  sArrayPushTiny(&(self->a), (smallt *) a);
1916  return(self);
1917 }
1918 
1919 internal smallArrayt* pushCArraycSmallArray(smallArrayt *self, const char **array) {
1920 
1921  // sanity checks
1922  if (!array) {
1923  return(NULL);
1924  }
1925 
1926  sArrayt *a = allocSArray();
1927  if (!a) {
1928  return(NULL);
1929  }
1930 
1931  forEachCCharP(array, e) {
1932  sStringt *s = allocSStringTiny(*e);
1933  if (!s) {
1934  return(NULL);
1935  }
1936  sArrayPushTiny(&a, (smallt *) s);
1937  }
1938  sArrayPushTiny(&(self->a), (smallt *) a);
1939  return(self);
1940 }
1941 
1942 internal smallArrayt* pushSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
1943 
1944  if (checkObjectTypes && value && !isOSmallBool(value)) {
1945  return(NULL);
1946  }
1947 
1948  if (!value) {
1949  return(NULL);
1950  }
1951 
1952  if (!value->value) {
1953  isError(value->value, allocSBool(false)) return(NULL);
1954  }
1955  sArrayPushTiny(&(self->a), (smallt *) value->value);
1956  return(self);
1957 }
1958 
1959 internal smallArrayt* pushSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
1960 
1961  if (checkObjectTypes && value && !isOSmallBytes(value)) {
1962  return(NULL);
1963  }
1964 
1965  if (!value) {
1966  return(NULL);
1967  }
1968 
1969  if (!value->B) {
1970  isError(value->B, allocSBytes()) return(NULL);
1971  }
1972  sArrayPushTiny(&(self->a), (smallt*) value->B);
1973  return(self);
1974 }
1975 
1976 internal smallArrayt* pushSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
1977 
1978  if (checkObjectTypes && value && !isOSmallDouble(value)) {
1979  return(NULL);
1980  }
1981 
1982  if (!value) {
1983  return(NULL);
1984  }
1985 
1986  if (!value->value) {
1987  isError(value->value, allocSDouble(0)) return(NULL);
1988  }
1989  sArrayPushTiny(&(self->a), (smallt *) value->value);
1990  return(self);
1991 }
1992 
1993 internal smallArrayt* pushSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
1994 
1995  if (checkObjectTypes && value && !isOSmallInt(value)) {
1996  return(NULL);
1997  }
1998 
1999  if (!value) {
2000  return(NULL);
2001  }
2002 
2003  if (!value->value) {
2004  isError(value->value, allocSInt(0)) return(NULL);
2005  }
2006  sArrayPushTiny(&(self->a), (smallt *) value->value);
2007  return(self);
2008 }
2009 
2010 internal smallArrayt* pushSmallJsonSmallArray(smallArrayt *self, smallJsont *value) {
2011 
2012  if (checkObjectTypes && value && !isOSmallJson(value)) {
2013  return(NULL);
2014  }
2015 
2016  if (!value) {
2017  return(NULL);
2018  }
2019 
2020  smallt *o = getsoO(value);
2021  if (!o) {
2022  // smallJson is empty, create an empty dict
2023  isError(o, (smallt*)allocSDict()) return(NULL);
2024  setsoO(value, o);
2025  }
2026 
2027  sArrayPushTiny(&(self->a), o);
2028  return(self);
2029 }
2030 
2031 internal smallArrayt* pushSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
2032 
2033  if (checkObjectTypes && string && !isOSmallString(string)) {
2034  return(NULL);
2035  }
2036 
2037  if (!string) {
2038  return(NULL);
2039  }
2040 
2041  if (!string->data) {
2042  isError(string->data, allocSStringTiny("")) return(NULL);
2043  }
2044  sArrayPushTiny(&(self->a), (smallt*) string->data);
2045  return(self);
2046 }
2047 
2048 internal smallArrayt* pushSmallContainerSmallArray(smallArrayt *self, smallContainert *container) {
2049 
2050  if (checkObjectTypes && container && !isOSmallContainer(container)) {
2051  return(NULL);
2052  }
2053 
2054  if (!container) {
2055  return(NULL);
2056  }
2057 
2058  if (!container->data) {
2059  isError(container->data, allocSContainer(NULL)) return(NULL);
2060  }
2061  sArrayPushTiny(&(self->a), (smallt *) container->data);
2062  return(self);
2063 }
2064 
2065 
2066 internal smallArrayt* pushNFreeSmallArray(smallArrayt *self, baset *value) {
2067  smallt *o = NULL;
2068 
2069  if (!value) {
2070  return(NULL);
2071  }
2072  o = toSmallt(value);;
2073  if (!o) {
2074  return(NULL);
2075  }
2076  sArrayPushTiny(&(self->a), o);
2077 
2078  if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) {
2079  finishO(value);
2080  }
2081  return(self);
2082 }
2083 
2084 internal smallArrayt* pushNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u) {
2085 
2086  smallArrayt *r = pushUndefinedSmallArray(self);;
2087  if (r) {
2088  terminateO(u);
2089  }
2090  return(r);
2091 }
2092 
2093 internal smallArrayt* pushNFreeSSmallArray(smallArrayt *self, char *string) {
2094 
2095  smallArrayt *r = pushSSmallArray(self, string);
2096  if (r) {
2097  free(string);
2098  }
2099  return(r);
2100 }
2101 
2102 internal smallArrayt* pushNFreeDictSmallArray(smallArrayt *self, smallDictt *dict) {
2103 
2104  smallArrayt *r = pushDictSmallArray(self, dict);
2105  if (r) {
2106  finishO(dict);
2107  }
2108  return(r);
2109 }
2110 
2111 internal smallArrayt* pushNFreeArraySmallArray(smallArrayt *self, smallArrayt *array) {
2112 
2113  smallArrayt *r = pushArraySmallArray(self, array);
2114  if (r) {
2115  finishO(array);
2116  }
2117  return(r);
2118 }
2119 
2120 internal smallArrayt* pushNFreeArraycSmallArray(smallArrayt *self, char **array) {
2121 
2122  smallArrayt *r = pushArraycSmallArray(self, array);
2123  if (r) {
2124  listFreeS(array);
2125  }
2126  return(r);
2127 }
2128 
2129 internal smallArrayt* pushNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
2130 
2131  smallArrayt *r = pushSmallBoolSmallArray(self, value);
2132  if (r) {
2133  finishO(value);
2134  }
2135  return(r);
2136 }
2137 
2138 internal smallArrayt* pushNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
2139 
2140  smallArrayt *r = pushSmallBytesSmallArray(self, value);
2141  if (r) {
2142  finishO(value);
2143  }
2144  return(r);
2145 }
2146 
2147 internal smallArrayt* pushNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
2148 
2149  smallArrayt *r = pushSmallDoubleSmallArray(self, value);
2150  if (r) {
2151  finishO(value);
2152  }
2153  return(r);
2154 }
2155 
2156 internal smallArrayt* pushNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
2157 
2158  smallArrayt *r = pushSmallIntSmallArray(self, value);
2159  if (r) {
2160  finishO(value);
2161  }
2162  return(r);
2163 }
2164 
2165 internal smallArrayt* pushNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *value) {
2166 
2167  smallArrayt *r = pushSmallJsonSmallArray(self, value);
2168  if (r) {
2169  finishO(value);
2170  }
2171  return(r);
2172 }
2173 
2174 internal smallArrayt* pushNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
2175 
2176  smallArrayt *r = pushSmallStringSmallArray(self, string);
2177  if (r) {
2178  finishO(string);
2179  }
2180  return(r);
2181 }
2182 
2183 internal smallArrayt* pushNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container) {
2184 
2185  smallArrayt *r = pushSmallContainerSmallArray(self, container);
2186  if (r) {
2187  finishO(container);
2188  }
2189  return(r);
2190 }
2191 
2192 internal smallArrayt* pushManySmallArray(smallArrayt *self, ...) {
2193  va_list pl;
2194  baset *paramType = NULL;
2195 
2196  // add arguments to a list
2197  va_start(pl, self);
2198  paramType = va_arg(pl, baset*);
2199  while (paramType) {
2200  smallArrayt *r = pushSmallArray(self, paramType);;
2201  if (!r) {
2202  va_end(pl);
2203  return(NULL);
2204  }
2205  paramType = va_arg(pl, baset*);
2206  }
2207  va_end(pl);
2208  return(self);
2209 }
2210 
2211 internal smallArrayt* pushManySSmallArray(smallArrayt *self, ...) {
2212  va_list pl;
2213  char *paramType = NULL;
2214 
2215  // add arguments to a list
2216  va_start(pl, self);
2217  paramType = va_arg(pl, char*);
2218  while (paramType) {
2219  smallArrayt *r = pushSSmallArray(self, paramType);;
2220  if (!r) {
2221  va_end(pl);
2222  return(NULL);
2223  }
2224  paramType = va_arg(pl, char*);
2225  }
2226  va_end(pl);
2227  return(self);
2228 }
2229 
2230 internal smallArrayt* pushNFreeManySmallArray(smallArrayt *self, ...) {
2231  va_list pl;
2232  baset *paramType = NULL;
2233 
2234  // add arguments to a list
2235  va_start(pl, self);
2236  paramType = va_arg(pl, baset*);
2237  while (paramType) {
2238  smallArrayt *r = pushNFreeSmallArray(self, paramType);;
2239  if (!r) {
2240  va_end(pl);
2241  return(NULL);
2242  }
2243  paramType = va_arg(pl, baset*);
2244  }
2245  va_end(pl);
2246  return(self);
2247 }
2248 
2249 internal smallArrayt* pushNFreeManySSmallArray(smallArrayt *self, ...) {
2250  va_list pl;
2251  char *paramType = NULL;
2252 
2253  // add arguments to a list
2254  va_start(pl, self);
2255  paramType = va_arg(pl, char*);
2256  while (paramType) {
2257  smallArrayt *r = pushNFreeSSmallArray(self, paramType);;
2258  if (!r) {
2259  va_end(pl);
2260  return(NULL);
2261  }
2262  paramType = va_arg(pl, char*);
2263  }
2264  va_end(pl);
2265  return(self);
2266 }
2267 
2268 
2269 internal baset* popSmallArray(smallArrayt *self) {
2270  size_t len;
2271  smallt *o = NULL;
2272 
2273  len = lenSmallArray(self);
2274  if (!len) {
2275  return(NULL);
2276  }
2277 
2278  for (size_t i = len ; i != 0 ; i--) {
2279  o = sArrayPopTiny(self->a);
2280  if (o) {
2281  break;
2282  }
2283  }
2284 
2285  if (!o) {
2286  return(NULL);
2287  }
2288 
2289  if (o->type == UNDEFINED) {
2290  free(o);
2291  return((baset*) allocUndefined());
2292  }
2293  else if (o->type == CONTAINER) {
2294  cast(sContainert*, sc, o);
2295  if (sc->dataType == SH_DT_BASET) {
2296  // baset object in stored in the container, free the container since
2297  // it was allocated automatically in the toSmallt function in libsheepyObject.c
2298  baset *r = toBaset(o);
2299  free(o);
2300  return(r);
2301  }
2302  }
2303  return(toBaset(o));
2304 }
2305 
2306 internal undefinedt* popUndefinedSmallArray(smallArrayt *self) {
2307  size_t len;
2308  smallt *o = NULL;
2309 
2310  len = lenSmallArray(self);
2311  if (!len) {
2312  return(NULL);
2313  }
2314 
2315  for (size_t i = len ; i != 0 ; i--) {
2316  o = sArrayGetTiny(self->a, self->a->count -1);
2317  if (o) {
2318  break;
2319  }
2320  self->a->count--;
2321  }
2322 
2323  if (!o) {
2324  return(NULL);
2325  }
2326 
2327  if (o->type != UNDEFINED) {
2328  return(NULL);
2329  }
2330 
2331  // finish poping
2332  free(o);
2333  self->a->count--;
2334  return(allocUndefined());
2335 }
2336 
2337 internal bool popBoolSmallArray(smallArrayt *self) {
2338  smallBoolt *e = NULL;
2339  bool r = false;;
2340 
2341  e = popSmallBoolSmallArray(self);
2342  if (e) {
2343  r = e->f->get(e);
2344  terminateO(e);
2345  }
2346  return(r);
2347 }
2348 
2349 internal double popDoubleSmallArray(smallArrayt *self) {
2350  smallDoublet *e = NULL;
2351  double r = 0;;
2352 
2353  e = popSmallDoubleSmallArray(self);
2354  if (e) {
2355  r = e->f->get(e);
2356  terminateO(e);
2357  }
2358  return(r);
2359 }
2360 
2361 internal int64_t popIntSmallArray(smallArrayt *self) {
2362  smallIntt *e = NULL;
2363  int64_t r = 0;;
2364 
2365  e = popSmallIntSmallArray(self);
2366  if (e) {
2367  r = e->f->get(e);
2368  terminateO(e);
2369  }
2370  return(r);
2371 }
2372 
2373 internal int32_t popInt32SmallArray(smallArrayt *self) {
2374  smallIntt *e = NULL;
2375  int32_t r = 0;;
2376 
2377  e = popSmallIntSmallArray(self);
2378  if (e) {
2379  r = (int32_t)e->f->get(e);
2380  terminateO(e);
2381  }
2382  return(r);
2383 }
2384 
2385 internal uint64_t popUintSmallArray(smallArrayt *self) {
2386  smallIntt *e = NULL;
2387  uint64_t r = 0;;
2388 
2389  e = popSmallIntSmallArray(self);
2390  if (e) {
2391  r = (uint64_t)e->f->get(e);
2392  terminateO(e);
2393  }
2394  return(r);
2395 }
2396 
2397 internal uint32_t popUint32SmallArray(smallArrayt *self) {
2398  smallIntt *e = NULL;
2399  uint32_t r = 0;;
2400 
2401  e = popSmallIntSmallArray(self);
2402  if (e) {
2403  r = (uint32_t)e->f->get(e);
2404  terminateO(e);
2405  }
2406  return(r);
2407 }
2408 
2409 internal char* popSSmallArray(smallArrayt *self) {
2410  smallStringt *e = NULL;
2411  char* r = NULL;
2412 
2413  e = popSmallStringSmallArray(self);
2414  if (e) {
2415  r = e->f->toString(e);
2416  terminateO(e);
2417  }
2418  return(r);
2419 }
2420 
2421 internal smallDictt* popDictSmallArray(smallArrayt *self) {
2422  size_t len;
2423  smallt *o = NULL;
2424 
2425  len = lenSmallArray(self);
2426  if (!len) {
2427  return(NULL);
2428  }
2429 
2430  for (size_t i = len ; i != 0 ; i--) {
2431  o = sArrayGetTiny(self->a, self->a->count -1);
2432  if (o) {
2433  break;
2434  }
2435  self->a->count--;
2436  }
2437 
2438  if (!o) {
2439  return(NULL);
2440  }
2441 
2442  if (o->type != DICT) {
2443  return(NULL);
2444  }
2445 
2446  // finish poping
2447  self->a->count--;
2448  return((smallDictt*)toBaset(o));
2449 }
2450 
2451 internal smallArrayt* popArraySmallArray(smallArrayt *self) {
2452  size_t len;
2453  smallt *o = NULL;
2454 
2455  len = lenSmallArray(self);
2456  if (!len) {
2457  return(NULL);
2458  }
2459 
2460  for (size_t i = len ; i != 0 ; i--) {
2461  o = sArrayGetTiny(self->a, self->a->count -1);
2462  if (o) {
2463  break;
2464  }
2465  self->a->count--;
2466  }
2467 
2468  if (!o) {
2469  return(NULL);
2470  }
2471 
2472  if (o->type != ARRAY) {
2473  return(NULL);
2474  }
2475 
2476  // finish poping
2477  self->a->count--;
2478  return((smallArrayt*)toBaset(o));
2479 }
2480 
2481 internal smallBoolt* popSmallBoolSmallArray(smallArrayt *self) {
2482  size_t len;
2483  smallt *o = NULL;
2484 
2485  len = lenSmallArray(self);
2486  if (!len) {
2487  return(NULL);
2488  }
2489 
2490  for (size_t i = len ; i != 0 ; i--) {
2491  o = sArrayGetTiny(self->a, self->a->count -1);
2492  if (o) {
2493  break;
2494  }
2495  self->a->count--;
2496  }
2497 
2498  if (!o) {
2499  return(NULL);
2500  }
2501 
2502  if (o->type != BOOL) {
2503  return(NULL);
2504  }
2505 
2506  // finish poping
2507  self->a->count--;
2508  return((smallBoolt*)toBaset(o));
2509 }
2510 
2511 internal smallBytest* popSmallBytesSmallArray(smallArrayt *self) {
2512  size_t len;
2513  smallt *o = NULL;
2514 
2515  len = lenSmallArray(self);
2516  if (!len) {
2517  return(NULL);
2518  }
2519 
2520  for (size_t i = len ; i != 0 ; i--) {
2521  o = sArrayGetTiny(self->a, self->a->count -1);
2522  if (o) {
2523  break;
2524  }
2525  self->a->count--;
2526  }
2527 
2528  if (!o) {
2529  return(NULL);
2530  }
2531 
2532  if (o->type != BYTES) {
2533  return(NULL);
2534  }
2535 
2536  // finish poping
2537  self->a->count--;
2538  return((smallBytest*)toBaset(o));
2539 }
2540 
2541 internal smallDoublet* popSmallDoubleSmallArray(smallArrayt *self) {
2542  size_t len;
2543  smallt *o = NULL;
2544 
2545  len = lenSmallArray(self);
2546  if (!len) {
2547  return(NULL);
2548  }
2549 
2550  for (size_t i = len ; i != 0 ; i--) {
2551  o = sArrayGetTiny(self->a, self->a->count -1);
2552  if (o) {
2553  break;
2554  }
2555  self->a->count--;
2556  }
2557 
2558  if (!o) {
2559  return(NULL);
2560  }
2561 
2562  if (o->type != DOUBLE) {
2563  return(NULL);
2564  }
2565 
2566  // finish poping
2567  self->a->count--;
2568  return((smallDoublet*)toBaset(o));
2569 }
2570 
2571 internal smallIntt* popSmallIntSmallArray(smallArrayt *self) {
2572  size_t len;
2573  smallt *o = NULL;
2574 
2575  len = lenSmallArray(self);
2576  if (!len) {
2577  return(NULL);
2578  }
2579 
2580  for (size_t i = len ; i != 0 ; i--) {
2581  o = sArrayGetTiny(self->a, self->a->count -1);
2582  if (o) {
2583  break;
2584  }
2585  self->a->count--;
2586  }
2587 
2588  if (!o) {
2589  return(NULL);
2590  }
2591 
2592  if (o->type != INT) {
2593  return(NULL);
2594  }
2595 
2596  // finish poping
2597  self->a->count--;
2598  return((smallIntt*)toBaset(o));
2599 }
2600 
2601 internal smallJsont* popSmallJsonSmallArray(smallArrayt *self) {
2602  size_t len;
2603  smallt *o = NULL;
2604 
2605  len = lenSmallArray(self);
2606  if (!len) {
2607  return(NULL);
2608  }
2609 
2610  for (size_t i = len ; i != 0 ; i--) {
2611  o = sArrayGetTiny(self->a, self->a->count -1);
2612  if (o) {
2613  break;
2614  }
2615  self->a->count--;
2616  }
2617 
2618  if (!o) {
2619  return(NULL);
2620  }
2621 
2622  if ((o->type == BYTES) || (o->type == CONTAINER)) {
2623  return(NULL);
2624  }
2625 
2626  // finish poping
2627  self->a->count--;
2628 
2629  baset *e = toBaset(o);
2630 
2631  createAllocateSmallJson(r);
2632  if (!r) {
2633  return(NULL);
2634  }
2635  setTopNFreeO(r, e);
2636  return(r);
2637 }
2638 
2639 internal smallStringt* popSmallStringSmallArray(smallArrayt *self) {
2640  size_t len;
2641  smallt *o = NULL;
2642 
2643  len = lenSmallArray(self);
2644  if (!len) {
2645  return(NULL);
2646  }
2647 
2648  for (size_t i = len ; i != 0 ; i--) {
2649  o = sArrayGetTiny(self->a, self->a->count -1);
2650  if (o) {
2651  break;
2652  }
2653  self->a->count--;
2654  }
2655 
2656  if (!o) {
2657  return(NULL);
2658  }
2659 
2660  if (o->type != STRING) {
2661  return(NULL);
2662  }
2663 
2664  // finish poping
2665  self->a->count--;
2666  return((smallStringt*)toBaset(o));
2667 }
2668 
2669 internal void* popVoidSmallArray(smallArrayt *self) {
2670  smallContainert *e = NULL;
2671  void* r = NULL;
2672 
2673  e = popSmallContainerSmallArray(self);
2674  if (e) {
2675  r = e->f->get(e);
2676  smashO(e);
2677  }
2678  return(r);
2679 }
2680 
2681 internal smallContainert* popSmallContainerSmallArray(smallArrayt *self) {
2682  size_t len;
2683  smallt *o = NULL;
2684 
2685  len = lenSmallArray(self);
2686  if (!len) {
2687  return(NULL);
2688  }
2689 
2690  for (size_t i = len ; i != 0 ; i--) {
2691  o = sArrayGetTiny(self->a, self->a->count -1);
2692  if (o) {
2693  break;
2694  }
2695  self->a->count--;
2696  }
2697 
2698  if (!o) {
2699  return(NULL);
2700  }
2701 
2702  if (o->type != CONTAINER) {
2703  return(NULL);
2704  }
2705 
2706  if (((sContainert*)o)->dataType == SH_DT_BASET) {
2707  return(NULL);
2708  }
2709 
2710  // finish poping
2711  self->a->count--;
2712  return((smallContainert*)toBaset(o));
2713 }
2714 
2715 internal double popNumSmallArray(smallArrayt *self) {
2716  size_t len;
2717  smallt *o = NULL;
2718 
2719  len = lenSmallArray(self);
2720  if (!len) {
2721  return(0);
2722  }
2723 
2724  for (size_t i = len ; i != 0 ; i--) {
2725  o = sArrayGetTiny(self->a, self->a->count -1);
2726  if (o) {
2727  break;
2728  }
2729  self->a->count--;
2730  }
2731 
2732  if (!o) {
2733  return(0);
2734  }
2735 
2736  if (o->type != INT && o->type != DOUBLE) {
2737  return(0);
2738  }
2739 
2740  baset *e = toBaset(o);
2741 
2742  // finish poping
2743  self->a->count--;
2744 
2745  double r = 0;
2746  if (isOSmallDouble(e)) {
2747  r = getValO((smallDoublet*)e);
2748  }
2749  elif (isOSmallInt(e)) {
2750  r = (double)getValO((smallIntt*)e);
2751  }
2752  terminateO(e);
2753  return(r);
2754 }
2755 
2756 internal smallArrayt* prependSmallArray(smallArrayt *self, baset *value) {
2757  smallt *o = NULL;
2758 
2759  if (!value) {
2760  return(NULL);
2761  }
2762 
2763  o = toSmallt(value);;
2764  if (!o) {
2765  return(NULL);
2766  }
2767  sArrayPrependTiny(&(self->a), o);
2768  return(self);
2769 }
2770 
2771 internal smallArrayt* prependUndefinedSmallArray(smallArrayt *self) {
2772 
2773  smallt *o = (smallt *) allocSUndefined();
2774  if (!o) {
2775  return(NULL);
2776  }
2777  sArrayPrependTiny(&(self->a), o);
2778  return(self);
2779 }
2780 
2781 internal smallArrayt* prependBoolSmallArray(smallArrayt *self, bool value) {
2782 
2783  smallt *o = (smallt *) allocSBool(value);
2784  if (!o) {
2785  return(NULL);
2786  }
2787  sArrayPrependTiny(&(self->a), o);
2788  return(self);
2789 }
2790 
2791 internal smallArrayt* prependDoubleSmallArray(smallArrayt *self, double value) {
2792 
2793  smallt *o = (smallt *) allocSDouble(value);
2794  if (!o) {
2795  return(NULL);
2796  }
2797  sArrayPrependTiny(&(self->a), o);
2798  return(self);
2799 }
2800 
2801 internal smallArrayt* prependIntSmallArray(smallArrayt *self, int64_t value) {
2802 
2803  smallt *o = (smallt *) allocSInt(value);
2804  if (!o) {
2805  return(NULL);
2806  }
2807  sArrayPrependTiny(&(self->a), o);
2808  return(self);
2809 }
2810 
2811 internal smallArrayt* prependSSmallArray(smallArrayt *self, const char *string) {
2812 
2813  smallt *o;
2814  if (!string) {
2815  return(NULL);
2816  }
2817  else {
2818  isError(o, (smallt *) allocSStringTiny(string)) return(NULL);
2819  }
2820  sArrayPrependTiny(&(self->a), o);
2821  return(self);
2822 }
2823 
2824 internal smallArrayt* prependCharSmallArray(smallArrayt *self, char c) {
2825 
2826  charToS(s, c);
2827  return(prependSSmallArray(self, s));
2828 }
2829 
2830 internal smallArrayt* prependDictSmallArray(smallArrayt *self, smallDictt *dict) {
2831 
2832  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
2833  return(NULL);
2834  }
2835 
2836  if (!dict) {
2837  return(NULL);
2838  }
2839 
2840  if (!dict->d) {
2841  isError(dict->d, allocSDict()) return(NULL);
2842  }
2843 
2844  sArrayPrependTiny(&(self->a), (smallt *)dict->d);
2845  return(self);
2846 }
2847 
2848 
2849 internal smallArrayt* prependArraySmallArray(smallArrayt *self, smallArrayt *array) {
2850 
2851  if (checkObjectTypes && array && !isOSmallArray(array)) {
2852  return(NULL);
2853  }
2854 
2855  if (!array) {
2856  return(NULL);
2857  }
2858 
2859  if (!array->a) {
2860  // allocate empty array
2861  isError(array->a, allocSArray()) return(NULL);
2862  }
2863 
2864  sArrayPrependTiny(&(self->a), (smallt *)array->a);
2865  return(self);
2866 }
2867 
2868 internal smallArrayt* prependArraycSmallArray(smallArrayt *self, char **array) {
2869 
2870  if (!array) {
2871  return(NULL);
2872  }
2873 
2874  sArrayt *a = allocSArray();
2875  if (!a) {
2876  return(NULL);
2877  }
2878 
2879  forEachCharP(array, e) {
2880  sStringt *s = allocSStringTiny(*e);
2881  if (!s) {
2882  return(NULL);
2883  }
2884  sArrayPushTiny(&a, (smallt *) s);
2885  }
2886  sArrayPrependTiny(&(self->a), (smallt *) a);
2887  return(self);
2888 }
2889 
2890 internal smallArrayt* prependCArraycSmallArray(smallArrayt *self, const char **array) {
2891 
2892  if (!array) {
2893  return(NULL);
2894  }
2895 
2896  sArrayt *a = allocSArray();
2897  if (!a) {
2898  return(NULL);
2899  }
2900 
2901  forEachCCharP(array, e) {
2902  sStringt *s = allocSStringTiny(*e);
2903  if (!s) {
2904  return(NULL);
2905  }
2906  sArrayPushTiny(&a, (smallt *) s);
2907  }
2908  sArrayPrependTiny(&(self->a), (smallt *) a);
2909  return(self);
2910 }
2911 
2912 internal smallArrayt* prependSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
2913 
2914  if (checkObjectTypes && value && !isOSmallBool(value)) {
2915  return(NULL);
2916  }
2917 
2918  if (!value) {
2919  return(NULL);
2920  }
2921 
2922  if (!value->value) {
2923  isError(value->value, allocSBool(false)) return(NULL);
2924  }
2925  sArrayPrependTiny(&(self->a), (smallt *) value->value);
2926  return(self);
2927 }
2928 
2929 internal smallArrayt* prependSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
2930 
2931  if (checkObjectTypes && value && !isOSmallBytes(value)) {
2932  return(NULL);
2933  }
2934 
2935  if (!value) {
2936  return(NULL);
2937  }
2938 
2939  if (!value->B) {
2940  isError(value->B, allocSBytes()) return(NULL);
2941  }
2942  sArrayPrependTiny(&(self->a), (smallt *) value->B);
2943  return(self);
2944 }
2945 
2946 internal smallArrayt* prependSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
2947 
2948  if (checkObjectTypes && value && !isOSmallDouble(value)) {
2949  return(NULL);
2950  }
2951 
2952  if (!value) {
2953  return(NULL);
2954  }
2955 
2956  if (!value->value) {
2957  isError(value->value, allocSDouble(0)) return(NULL);
2958  }
2959  sArrayPrependTiny(&(self->a), (smallt *) value->value);
2960  return(self);
2961 }
2962 
2963 internal smallArrayt* prependSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
2964 
2965  if (checkObjectTypes && value && !isOSmallInt(value)) {
2966  return(NULL);
2967  }
2968 
2969  if (!value) {
2970  return(NULL);
2971  }
2972 
2973  if (!value->value) {
2974  isError(value->value, allocSInt(0)) return(NULL);
2975  }
2976  sArrayPrependTiny(&(self->a), (smallt *) value->value);
2977  return(self);
2978 }
2979 
2980 internal smallArrayt* prependSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
2981 
2982  if (checkObjectTypes && json && !isOSmallJson(json)) {
2983  return(NULL);
2984  }
2985 
2986  if (!json) {
2987  return(NULL);
2988  }
2989 
2990  smallt *o = getsoO(json);
2991  if (!o) {
2992  // smallJson is empty, create an empty dict
2993  isError(o, (smallt*)allocSDict()) return(NULL);
2994  setsoO(json, o);
2995  }
2996 
2997  sArrayPrependTiny(&(self->a), o);
2998  return(self);
2999 }
3000 
3001 internal smallArrayt* prependSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
3002 
3003  if (checkObjectTypes && string && !isOSmallString(string)) {
3004  return(NULL);
3005  }
3006 
3007  if (!string) {
3008  return(NULL);
3009  }
3010 
3011  if (!string->data) {
3012  isError(string->data, allocSStringTiny("")) return(NULL);
3013  }
3014  sArrayPrependTiny(&(self->a), (smallt *) string->data);
3015  return(self);
3016 }
3017 
3018 internal smallArrayt* prependSmallContainerSmallArray(smallArrayt *self, smallContainert *container) {
3019 
3020  if (checkObjectTypes && container && !isOSmallContainer(container)) {
3021  return(NULL);
3022  }
3023 
3024  if (!container) {
3025  return(NULL);
3026  }
3027 
3028  if (!container->data) {
3029  isError(container->data, allocSContainer(NULL)) return(NULL);
3030  }
3031  sArrayPrependTiny(&(self->a), (smallt *) container->data);
3032  return(self);
3033 }
3034 
3035 
3036 internal smallArrayt* prependNFreeSmallArray(smallArrayt *self, baset *value) {
3037  smallt *o = NULL;
3038 
3039  if (!value) {
3040  return(NULL);
3041  }
3042 
3043  o = toSmallt(value);;
3044  if (!o) {
3045  return(NULL);
3046  }
3047  sArrayPrependTiny(&(self->a), o);
3048 
3049  if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) {
3050  finishO(value);
3051  }
3052  return(self);
3053 }
3054 
3055 internal smallArrayt* prependNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u) {
3056 
3057  smallArrayt *r = prependUndefinedSmallArray(self);;
3058  if (r) {
3059  terminateO(u);
3060  }
3061  return(self);
3062 }
3063 
3064 internal smallArrayt* prependNFreeSSmallArray(smallArrayt *self, char *string) {
3065 
3066  smallArrayt *r = prependSSmallArray(self, string);
3067  if (r) {
3068  free(string);
3069  }
3070  return(r);
3071 }
3072 
3073 internal smallArrayt* prependNFreeDictSmallArray(smallArrayt *self, smallDictt *dict) {
3074 
3075  smallArrayt *r = prependDictSmallArray(self, dict);
3076  if (r) {
3077  finishO(dict);
3078  }
3079  return(r);
3080 }
3081 
3082 internal smallArrayt* prependNFreeArraySmallArray(smallArrayt *self, smallArrayt *array) {
3083 
3084  smallArrayt *r = prependArraySmallArray(self, array);
3085  if (r) {
3086  finishO(array);
3087  }
3088  return(r);
3089 }
3090 
3091 internal smallArrayt* prependNFreeArraycSmallArray(smallArrayt *self, char **array) {
3092 
3093  smallArrayt *r = prependArraycSmallArray(self, array);
3094  if (r) {
3095  listFreeS(array);
3096  }
3097  return(r);
3098 }
3099 
3100 internal smallArrayt* prependNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
3101 
3102  smallArrayt *r = prependSmallBoolSmallArray(self, value);
3103  if (r) {
3104  finishO(value);
3105  }
3106  return(r);
3107 }
3108 
3109 internal smallArrayt* prependNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
3110 
3111  smallArrayt *r = prependSmallBytesSmallArray(self, value);
3112  if (r) {
3113  finishO(value);
3114  }
3115  return(r);
3116 }
3117 
3118 internal smallArrayt* prependNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
3119 
3120  smallArrayt *r = prependSmallDoubleSmallArray(self, value);
3121  if (r) {
3122  finishO(value);
3123  }
3124  return(r);
3125 }
3126 
3127 internal smallArrayt* prependNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
3128 
3129  smallArrayt *r = prependSmallIntSmallArray(self, value);
3130  if (r) {
3131  finishO(value);
3132  }
3133  return(r);
3134 }
3135 
3136 internal smallArrayt* prependNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
3137 
3138  smallArrayt *r = prependSmallJsonSmallArray(self, json);
3139  if (r) {
3140  finishO(json);
3141  }
3142  return(r);
3143 }
3144 
3145 internal smallArrayt* prependNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
3146 
3147  smallArrayt *r = prependSmallStringSmallArray(self, string);
3148  if (r) {
3149  finishO(string);
3150  }
3151  return(r);
3152 }
3153 
3154 internal smallArrayt* prependNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container) {
3155 
3156  smallArrayt *r = prependSmallContainerSmallArray(self, container);
3157  if (r) {
3158  finishO(container);
3159  }
3160  return(r);
3161 }
3162 
3163 internal baset* dequeueSmallArray(smallArrayt *self) {
3164  size_t len;
3165  smallt *o = NULL;
3166 
3167  len = lenSmallArray(self);
3168  if (!len) {
3169  return(NULL);
3170  }
3171 
3172  for (size_t i = len ; i != 0 ; i--) {
3173  o = sArrayDequeueTiny(self->a);
3174  if (o) {
3175  break;
3176  }
3177  }
3178 
3179  if (!o) {
3180  return(NULL);
3181  }
3182 
3183  if (o->type == UNDEFINED) {
3184  free(o);
3185  return((baset*) allocUndefined());
3186  }
3187  else if (o->type == CONTAINER) {
3188  cast(sContainert*, sc, o);
3189  if (sc->dataType == SH_DT_BASET) {
3190  // baset object in stored in the container, free the container since
3191  // it was allocated automatically in the toSmallt function in libsheepyObject.c
3192  baset *r = toBaset(o);
3193  free(o);
3194  return(r);
3195  }
3196  }
3197  return(toBaset(o));
3198 }
3199 
3200 internal undefinedt* dequeueUndefinedSmallArray(smallArrayt *self) {
3201  size_t len;
3202  smallt *o = NULL;
3203 
3204  len = lenSmallArray(self);
3205  if (!len) {
3206  return(NULL);
3207  }
3208 
3209  size_t i;
3210  for (i = 0 ; i < len ; i++) {
3211  o = sArrayGetTiny(self->a, (uint32_t)i);
3212  if (o) {
3213  break;
3214  }
3215  }
3216 
3217  if (!o) {
3218  return(NULL);
3219  }
3220 
3221  if (o->type != UNDEFINED) {
3222  return(NULL);
3223  }
3224 
3225  // finish dequeuing
3226  smallt **arr = &(self->a->data);
3227  // shift list
3228  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3229  arr[j-i-1] = arr[j];
3230  }
3231  self->a->count -= (uint32_t)i+1;
3232 
3233  free(o);
3234  return(allocUndefined());
3235 }
3236 
3237 internal bool dequeueBoolSmallArray(smallArrayt *self) {
3238  smallBoolt *e = NULL;
3239  bool r = false;;
3240 
3241  e = dequeueSmallBoolSmallArray(self);
3242  if (e) {
3243  r = e->f->get(e);
3244  terminateO(e);
3245  }
3246  return(r);
3247 }
3248 
3249 internal double dequeueDoubleSmallArray(smallArrayt *self) {
3250  smallDoublet *e = NULL;
3251  double r = 0;;
3252 
3253  e = dequeueSmallDoubleSmallArray(self);
3254  if (e) {
3255  r = e->f->get(e);
3256  terminateO(e);
3257  }
3258  return(r);
3259 }
3260 
3261 internal int64_t dequeueIntSmallArray(smallArrayt *self) {
3262  smallIntt *e = NULL;
3263  int64_t r = 0;;
3264 
3265  e = dequeueSmallIntSmallArray(self);
3266  if (e) {
3267  r = e->f->get(e);
3268  terminateO(e);
3269  }
3270  return(r);
3271 }
3272 
3273 internal int32_t dequeueInt32SmallArray(smallArrayt *self) {
3274  smallIntt *e = NULL;
3275  int32_t r = 0;;
3276 
3277  e = dequeueSmallIntSmallArray(self);
3278  if (e) {
3279  r = (int32_t)e->f->get(e);
3280  terminateO(e);
3281  }
3282  return(r);
3283 }
3284 
3285 internal uint64_t dequeueUintSmallArray(smallArrayt *self) {
3286  smallIntt *e = NULL;
3287  uint64_t r = 0;;
3288 
3289  e = dequeueSmallIntSmallArray(self);
3290  if (e) {
3291  r = (uint64_t)e->f->get(e);
3292  terminateO(e);
3293  }
3294  return(r);
3295 }
3296 
3297 internal uint32_t dequeueUint32SmallArray(smallArrayt *self) {
3298  smallIntt *e = NULL;
3299  uint32_t r = 0;;
3300 
3301  e = dequeueSmallIntSmallArray(self);
3302  if (e) {
3303  r = (uint32_t)e->f->get(e);
3304  terminateO(e);
3305  }
3306  return(r);
3307 }
3308 
3309 internal char* dequeueSSmallArray(smallArrayt *self) {
3310  smallStringt *e = NULL;
3311  char* r = NULL;
3312 
3313  e = dequeueSmallStringSmallArray(self);
3314  if (e) {
3315  r = e->f->toString(e);
3316  terminateO(e);
3317  }
3318  return(r);
3319 }
3320 
3321 internal smallDictt* dequeueDictSmallArray(smallArrayt *self) {
3322  size_t len;
3323  smallt *o = NULL;
3324 
3325  len = lenSmallArray(self);
3326  if (!len) {
3327  return(NULL);
3328  }
3329 
3330  size_t i;
3331  for (i = 0 ; i < len ; i++) {
3332  o = sArrayGetTiny(self->a, (uint32_t)i);
3333  if (o) {
3334  break;
3335  }
3336  }
3337 
3338  if (!o) {
3339  return(NULL);
3340  }
3341 
3342  if (o->type != DICT) {
3343  return(NULL);
3344  }
3345 
3346  // finish dequeuing
3347  smallt **arr = &(self->a->data);
3348  // shift list
3349  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3350  arr[j-i-1] = arr[j];
3351  }
3352  self->a->count -= (uint32_t)i+1;
3353 
3354  return((smallDictt*) toBaset(o));
3355 }
3356 
3357 internal smallArrayt* dequeueArraySmallArray(smallArrayt *self) {
3358  size_t len;
3359  smallt *o = NULL;
3360 
3361  len = lenSmallArray(self);
3362  if (!len) {
3363  return(NULL);
3364  }
3365 
3366  size_t i;
3367  for (i = 0 ; i < len ; i++) {
3368  o = sArrayGetTiny(self->a, (uint32_t)i);
3369  if (o) {
3370  break;
3371  }
3372  }
3373 
3374  if (!o) {
3375  return(NULL);
3376  }
3377 
3378  if (o->type != ARRAY) {
3379  return(NULL);
3380  }
3381 
3382  // finish dequeuing
3383  smallt **arr = &(self->a->data);
3384  // shift list
3385  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3386  arr[j-i-1] = arr[j];
3387  }
3388  self->a->count -= (uint32_t)i+1;
3389 
3390  return((smallArrayt*) toBaset(o));
3391 }
3392 
3393 internal smallBoolt* dequeueSmallBoolSmallArray(smallArrayt *self) {
3394  size_t len;
3395  smallt *o = NULL;
3396 
3397  len = lenSmallArray(self);
3398  if (!len) {
3399  return(NULL);
3400  }
3401 
3402  size_t i;
3403  for (i = 0 ; i < len ; i++) {
3404  o = sArrayGetTiny(self->a, (uint32_t)i);
3405  if (o) {
3406  break;
3407  }
3408  }
3409 
3410  if (!o) {
3411  return(NULL);
3412  }
3413 
3414  if (o->type != BOOL) {
3415  return(NULL);
3416  }
3417 
3418  // finish dequeuing
3419  smallt **arr = &(self->a->data);
3420  // shift list
3421  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3422  arr[j-i-1] = arr[j];
3423  }
3424  self->a->count -= (uint32_t)i+1;
3425 
3426  return((smallBoolt*) toBaset(o));
3427 }
3428 
3429 internal smallBytest* dequeueSmallBytesSmallArray(smallArrayt *self) {
3430  size_t len;
3431  smallt *o = NULL;
3432 
3433  len = lenSmallArray(self);
3434  if (!len) {
3435  return(NULL);
3436  }
3437 
3438  size_t i;
3439  for (i = 0 ; i < len ; i++) {
3440  o = sArrayGetTiny(self->a, (uint32_t)i);
3441  if (o) {
3442  break;
3443  }
3444  }
3445 
3446  if (!o) {
3447  return(NULL);
3448  }
3449 
3450  if (o->type != BYTES) {
3451  return(NULL);
3452  }
3453 
3454  // finish dequeuing
3455  smallt **arr = &(self->a->data);
3456  // shift list
3457  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3458  arr[j-i-1] = arr[j];
3459  }
3460  self->a->count -= (uint32_t)i+1;
3461 
3462  return((smallBytest*) toBaset(o));
3463 }
3464 
3465 internal smallDoublet* dequeueSmallDoubleSmallArray(smallArrayt *self) {
3466  size_t len;
3467  smallt *o = NULL;
3468 
3469  len = lenSmallArray(self);
3470  if (!len) {
3471  return(NULL);
3472  }
3473 
3474  size_t i;
3475  for (i = 0 ; i < len ; i++) {
3476  o = sArrayGetTiny(self->a, (uint32_t)i);
3477  if (o) {
3478  break;
3479  }
3480  }
3481 
3482  if (!o) {
3483  return(NULL);
3484  }
3485 
3486  if (o->type != DOUBLE) {
3487  return(NULL);
3488  }
3489 
3490  // finish dequeuing
3491  smallt **arr = &(self->a->data);
3492  // shift list
3493  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3494  arr[j-i-1] = arr[j];
3495  }
3496  self->a->count -= (uint32_t)i+1;
3497 
3498  return((smallDoublet*) toBaset(o));
3499 }
3500 
3501 internal smallIntt* dequeueSmallIntSmallArray(smallArrayt *self) {
3502  size_t len;
3503  smallt *o = NULL;
3504 
3505  len = lenSmallArray(self);
3506  if (!len) {
3507  return(NULL);
3508  }
3509 
3510  size_t i;
3511  for (i = 0 ; i < len ; i++) {
3512  o = sArrayGetTiny(self->a, (uint32_t)i);
3513  if (o) {
3514  break;
3515  }
3516  }
3517 
3518  if (!o) {
3519  return(NULL);
3520  }
3521 
3522  if (o->type != INT) {
3523  return(NULL);
3524  }
3525 
3526  // finish dequeuing
3527  smallt **arr = &(self->a->data);
3528  // shift list
3529  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3530  arr[j-i-1] = arr[j];
3531  }
3532  self->a->count -= (uint32_t)i+1;
3533 
3534  return((smallIntt*) toBaset(o));
3535 }
3536 
3537 internal smallJsont* dequeueSmallJsonSmallArray(smallArrayt *self) {
3538  size_t len;
3539  smallt *o = NULL;
3540 
3541  len = lenSmallArray(self);
3542  if (!len) {
3543  return(NULL);
3544  }
3545 
3546  size_t i;
3547  for (i = 0 ; i < len ; i++) {
3548  o = sArrayGetTiny(self->a, (uint32_t)i);
3549  if (o) {
3550  break;
3551  }
3552  }
3553 
3554  if (!o) {
3555  return(NULL);
3556  }
3557 
3558  if ((o->type == BYTES) || (o->type == CONTAINER)) {
3559  return(NULL);
3560  }
3561 
3562  // finish dequeuing
3563  smallt **arr = &(self->a->data);
3564  // shift list
3565  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3566  arr[j-i-1] = arr[j];
3567  }
3568  self->a->count -= (uint32_t)i+1;
3569 
3570  baset *e = toBaset(o);
3571 
3572  createAllocateSmallJson(r);
3573  if (!r) {
3574  return(NULL);
3575  }
3576  setTopNFreeO(r, e);
3577  return(r);
3578 }
3579 
3580 internal smallStringt* dequeueSmallStringSmallArray(smallArrayt *self) {
3581  size_t len;
3582  smallt *o = NULL;
3583 
3584  len = lenSmallArray(self);
3585  if (!len) {
3586  return(NULL);
3587  }
3588 
3589  size_t i;
3590  for (i = 0 ; i < len ; i++) {
3591  o = sArrayGetTiny(self->a, (uint32_t)i);
3592  if (o) {
3593  break;
3594  }
3595  }
3596 
3597  if (!o) {
3598  return(NULL);
3599  }
3600 
3601  if (o->type != STRING) {
3602  return(NULL);
3603  }
3604 
3605  // finish dequeuing
3606  smallt **arr = &(self->a->data);
3607  // shift list
3608  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3609  arr[j-i-1] = arr[j];
3610  }
3611  self->a->count -= (uint32_t)i+1;
3612 
3613  return((smallStringt*) toBaset(o));
3614 }
3615 
3616 internal void* dequeueVoidSmallArray(smallArrayt *self) {
3617  smallContainert *e = NULL;
3618  void* r = NULL;
3619 
3620  e = dequeueSmallContainerSmallArray(self);
3621  if (e) {
3622  r = e->f->get(e);
3623  smashO(e);
3624  }
3625  return(r);
3626 }
3627 
3628 internal smallContainert* dequeueSmallContainerSmallArray(smallArrayt *self) {
3629  size_t len;
3630  smallt *o = NULL;
3631 
3632  len = lenSmallArray(self);
3633  if (!len) {
3634  return(NULL);
3635  }
3636 
3637  size_t i;
3638  for (i = 0 ; i < len ; i++) {
3639  o = sArrayGetTiny(self->a, (uint32_t)i);
3640  if (o) {
3641  break;
3642  }
3643  }
3644 
3645  if (!o) {
3646  return(NULL);
3647  }
3648 
3649  if (o->type != CONTAINER) {
3650  return(NULL);
3651  }
3652 
3653  if (((sContainert*)o)->dataType == SH_DT_BASET) {
3654  return(NULL);
3655  }
3656 
3657  // finish dequeuing
3658  smallt **arr = &(self->a->data);
3659  // shift list
3660  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3661  arr[j-i-1] = arr[j];
3662  }
3663  self->a->count -= (uint32_t)i+1;
3664 
3665  return((smallContainert*) toBaset(o));
3666 }
3667 
3668 internal double dequeueNumSmallArray(smallArrayt *self) {
3669  size_t len;
3670  smallt *o = NULL;
3671 
3672  len = lenSmallArray(self);
3673  if (!len) {
3674  return(0);
3675  }
3676 
3677  size_t i;
3678  for (i = 0 ; i < len ; i++) {
3679  o = sArrayGetTiny(self->a, (uint32_t)i);
3680  if (o) {
3681  break;
3682  }
3683  }
3684 
3685  if (!o) {
3686  return(0);
3687  }
3688 
3689  if (o->type != INT && o->type != DOUBLE) {
3690  return(0);
3691  }
3692 
3693  // finish dequeuing
3694  smallt **arr = &(self->a->data);
3695  // shift list
3696  for (uint32_t j = (uint32_t)i+1 ; j < self->a->count ; j++) {
3697  arr[j-i-1] = arr[j];
3698  }
3699  self->a->count -= (uint32_t)i+1;
3700 
3701  baset *e = toBaset(o);
3702 
3703  double r = 0;
3704  if (isOSmallDouble(e)) {
3705  r = getValO((smallDoublet*)e);
3706  }
3707  elif (isOSmallInt(e)) {
3708  r = (double)getValO((smallIntt*)e);
3709  }
3710  terminateO(e);
3711  return(r);
3712 }
3713 
3714 internal smallArrayt* reverseSmallArray(smallArrayt *self) {
3715  size_t len;
3716 
3717  len = lenSmallArray(self);
3718 
3719  if (len < 2) {
3720  // empty or 1 element list
3721  return(self);
3722  }
3723 
3724  if (!sArrayReverseTiny(self->a)) {
3725  return(NULL);
3726  }
3727  return(self);
3728 }
3729 
3730 internal smallArrayt* catSmallArray(smallArrayt *self, ...) {
3731  va_list pl;
3732  smallArrayt *paramType = NULL;
3733 
3734  // add arguments to a list
3735  va_start(pl, self);
3736  paramType = va_arg(pl, smallArrayt*);
3737  while (paramType) {
3738  smallArrayt *r = appendSmallArray(self, paramType);;
3739  if (!r) {
3740  va_end(pl);
3741  return(NULL);
3742  }
3743  paramType = va_arg(pl, smallArrayt*);
3744  }
3745  va_end(pl);
3746  return(self);
3747 }
3748 
3749 internal smallArrayt* appendSmallArray(smallArrayt *self, smallArrayt *array) {
3750 
3751  // sanity checks
3752  if (!array) {
3753  return(NULL);
3754  }
3755 
3756  if (checkObjectTypes && !isOSmallArray(array)) {
3757  return(NULL);
3758  }
3759 
3760  if (!array->f->len(array)) {
3761  // self not modified
3762  return(self);
3763  }
3764 
3765  if (self->a == array->a) {
3766  // self and array identical, cancel this operations
3767  // to avoid double free undefined behavior in free
3768  return(NULL);
3769  }
3770 
3771  // copy array
3772  forEachSArray(array->a, o) {
3773  sArrayPushTiny(&(self->a), o);
3774  }
3775 
3776  return(self);
3777 }
3778 
3779 internal smallArrayt* appendSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
3780 
3781  // sanity checks
3782  if (!json) {
3783  return(NULL);
3784  }
3785 
3786  if (checkObjectTypes && !isOSmallJson(json)) {
3787  return(NULL);
3788  }
3789 
3790  const char *type = getTopTypeO(json);
3791 
3792  if (!eqS(type,"array")) {
3793  return(NULL);
3794  }
3795 
3796  if (!json->f->len(json)) {
3797  // self not modified
3798  return(self);
3799  }
3800 
3801  if (self->a == json->topA) {
3802  // self and array identical, cancel this operations
3803  // to avoid double free undefined behavior in free
3804  return(NULL);
3805  }
3806 
3807  // copy array
3808  forEachSArray(json->topA, o) {
3809  sArrayPushTiny(&(self->a), o);
3810  }
3811 
3812  return(self);
3813 }
3814 
3815 internal smallArrayt* appendNSmashSmallArray(smallArrayt *self, smallArrayt *array) {
3816  smallArrayt *r = NULL;
3817 
3818  r = appendSmallArray(self, array);
3819  if (r) {
3820  smashO(array);
3821  }
3822  return(r);
3823 }
3824 
3825 internal smallArrayt* appendNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
3826  smallArrayt *r = NULL;
3827 
3828  r = appendSmallJsonSmallArray(self, json);
3829  if (r) {
3830  smashO(json);
3831  }
3832  return(r);
3833 }
3834 
3835 internal smallArrayt* appendArraySmallArray(smallArrayt *self, char **array) {
3836 
3837  if (!array) {
3838  return(NULL);
3839  }
3840 
3841  if (!*array) {
3842  return(self);
3843  }
3844 
3845  forEachCharP(array, e) {
3846  sStringt *s = allocSStringTiny(*e);
3847  if (!s) {
3848  return(NULL);
3849  }
3850  sArrayPushTiny(&(self->a), (smallt *) s);
3851  }
3852  return(self);
3853 }
3854 
3855 internal smallArrayt* appendCArraySmallArray(smallArrayt *self, const char **array) {
3856 
3857  if (!array) {
3858  return(NULL);
3859  }
3860 
3861  if (!*array) {
3862  return(self);
3863  }
3864 
3865  forEachCCharP(array, e) {
3866  sStringt *s = allocSStringTiny(*e);
3867  if (!s) {
3868  return(NULL);
3869  }
3870  sArrayPushTiny(&(self->a), (smallt *) s);
3871  }
3872  return(self);
3873 }
3874 
3875 internal smallArrayt* appendNSmashArraySmallArray(smallArrayt *self, char **array) {
3876 
3877  if (!array) {
3878  return(NULL);
3879  }
3880 
3881  if (!*array) {
3882  free(array);
3883  return(self);
3884  }
3885 
3886  forEachCharP(array, e) {
3887  sStringt *s = allocSStringTiny(*e);
3888  if (!s) {
3889  // keep array when there is an error
3890  return(NULL);
3891  }
3892  sArrayPushTiny(&(self->a), (smallt *) s);
3893  }
3894 
3895  listFreeS(array);
3896  return(self);
3897 }
3898 
3899 internal smallArrayt* shiftSmallArray(smallArrayt *self, smallArrayt *array) {
3900 
3901  return(insertSmallArray(self, 0, array));
3902 }
3903 
3904 internal smallArrayt* shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
3905 
3906  return(insertSmallJsonSmallArray(self, 0, json));
3907 }
3908 
3909 internal smallArrayt* shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array) {
3910 
3911  return(insertNSmashSmallArray(self, 0, array));
3912 }
3913 
3914 internal smallArrayt* shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json) {
3915 
3916  return(insertNSmashSmallJsonSmallArray(self, 0, json));
3917 }
3918 
3919 
3920 internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array) {
3921  smallArrayt *r = NULL;
3922 
3923  // sanity checks
3924  if (!array) {
3925  return(NULL);
3926  }
3927 
3928  if (checkObjectTypes && !isOSmallArray(array)) {
3929  return(NULL);
3930  }
3931 
3932  if (!array->f->len(array)) {
3933  return(duplicateSmallArray(self));
3934  }
3935 
3936  if (self->a == array->a) {
3937  // self and array identical, cancel this operations
3938  // to avoid double free undefined behavior in free
3939  return(NULL);
3940  }
3941 
3942  r = duplicateSmallArray(self);
3943 
3944  // copy array
3945  forEachSArray(array->a, o) {
3946  sArrayPushTiny(&(r->a), o);
3947  }
3948 
3949  return(r);
3950 }
3951 
3952 internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end) {
3953  size_t len;
3954 
3955  len = lenSmallArray(self);
3956  // sanity checks
3957  if (!len) {
3958  return(NULL);
3959  }
3960 
3961  if (start > (int64_t)len) {
3962  emptySmallArray(self);
3963  return(NULL);
3964  }
3965  if (end > (int64_t)len) {
3966  end = (int64_t)len;
3967  }
3968  if (start <= -(int64_t)len) {
3969  start = -(int64_t)len;
3970  }
3971  if (end <= -(int64_t)len) {
3972  emptySmallArray(self);
3973  return(NULL);
3974  }
3975  if (start < 0) {
3976  start = (int64_t)len + start;
3977  }
3978  if (end <= 0) {
3979  end = (int64_t)len + end;
3980  }
3981  if (end < start) {
3982  emptySmallArray(self);
3983  return(NULL);
3984  }
3985 
3986  if (start == end) {
3987  // empty list
3988  freeSmallArray(self);
3989  return(self);
3990  }
3991  else {
3992  // start < end < len
3993 
3994  sArrayDelRangeTiny(self->a, (uint32_t)end, (uint32_t)len);
3995  sArrayDelRangeTiny(self->a, 0, (uint32_t)start);
3996  }
3997 
3998  return(self);
3999 }
4000 
4001 internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end) {
4002  size_t len;
4003  smallt *o = NULL;
4004 
4005  len = lenSmallArray(self);
4006  // sanity checks
4007  if (!len) {
4008  return(NULL);
4009  }
4010 
4011  if (start > (int64_t)len) {
4012  return(NULL);
4013  }
4014  if (end > (int64_t)len) {
4015  end = (int64_t)len;
4016  }
4017  if (start <= -(int64_t)len) {
4018  start = -(int64_t)len;
4019  }
4020  if (end <= -(int64_t)len) {
4021  return(NULL);
4022  }
4023  if (start < 0) {
4024  start = (int64_t)len + start;
4025  }
4026  if (end <= 0) {
4027  end = (int64_t)len + end;
4028  }
4029  if (end < start) {
4030  return(NULL);
4031  }
4032 
4033  createAllocateSmallArray(r);
4034  if (!r) {
4035  return(NULL);
4036  }
4037 
4038  if (start < end) {
4039  // start < end < len
4040  int64_t n;
4041  n = end - start;
4042 
4043  for (int64_t i=0;i < n;i++) {
4044  o = sArrayGetTiny(self->a, (uint32_t)(start+i));
4045  sArrayPushTiny(&(r->a), o);
4046  }
4047 
4048  // copy pointers from range end, array->count to start
4049  smallt **arr = &(self->a->data);
4050 
4051  for (uint32_t i = 0 ; i < (self->a->count - end) ; i ++) {
4052  arr[start+i] = arr[end + i];
4053  }
4054 
4055  self->a->count -= (uint32_t)(end - start);
4056  }
4057 
4058  return(r);
4059 }
4060 
4061 internal baset* cropElemSmallArray(smallArrayt *self, int64_t index) {
4062  baset *r = NULL;
4063 
4064  if (index >= (int64_t)lenSmallArray(self)) {
4065  return(NULL);
4066  }
4067  if (index < -(int64_t)lenSmallArray(self)) {
4068  return(NULL);
4069  }
4070  if (index < 0) {
4071  index = (int64_t)lenSmallArray(self) + index;
4072  }
4073 
4074  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);;
4075  if (!o) {
4076  return(NULL);
4077  }
4078 
4079  if (o->type == UNDEFINED) {
4080  free(o);
4081  r = (baset*) allocUndefined();
4082  goto removeElem;
4083  }
4084  else if (o->type == CONTAINER) {
4085  cast(sContainert*, sc, o);
4086  if (sc->dataType == SH_DT_BASET) {
4087  // baset object in stored in the container, free the container since
4088  // it was allocated automatically in the toSmallt function in libsheepyObject.c
4089  r = toBaset(o);
4090  free(o);
4091  goto removeElem;
4092  }
4093  }
4094  r = toBaset(o);;
4095 
4096  removeElem:;
4097 
4098  // copy pointers from range index+1, array->count to index
4099  smallt **arr = &(self->a->data);
4100 
4101  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4102  arr[index+i] = arr[index+1 + i];
4103  }
4104 
4105  self->a->count--;
4106 
4107  return(r);
4108 }
4109 
4110 
4111 internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index) {
4112 
4113  if (index >= (int64_t)lenSmallArray(self)) {
4114  return(NULL);
4115  }
4116  if (index < -(int64_t)lenSmallArray(self)) {
4117  return(NULL);
4118  }
4119  if (index < 0) {
4120  index = (int64_t)lenSmallArray(self) + index;
4121  }
4122 
4123  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);;
4124  if (!o) {
4125  return(NULL);
4126  }
4127  if (o->type != UNDEFINED) {
4128  return(NULL);
4129  }
4130 
4131  free(o);
4132  undefinedt *r = allocUndefined();
4133 
4134  // copy pointers from range index+1, array->count to index
4135  smallt **arr = &(self->a->data);
4136 
4137  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4138  arr[index+i] = arr[index+1 + i];
4139  }
4140 
4141  self->a->count--;
4142 
4143  return(r);
4144 }
4145 
4146 
4147 internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index) {
4148 
4149  if (index >= (int64_t)lenSmallArray(self)) {
4150  return(false);
4151  }
4152  if (index < -(int64_t)lenSmallArray(self)) {
4153  return(false);
4154  }
4155  if (index < 0) {
4156  index = (int64_t)lenSmallArray(self) + index;
4157  }
4158 
4159  bool r = false;
4160  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4161  if (!o) {
4162  return(false);
4163  }
4164  smallBoolt *e = (smallBoolt*)toBaset(o);
4165  if (e) {
4166  if (checkObjectTypes && !isOSmallBool(e)) {
4167  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4168  return(false);
4169  }
4170  finishO(e);
4171  return(false);
4172  }
4173  r = e->f->get(e);
4174  terminateO(e);
4175 
4176  // copy pointers from range index+1, array->count to index
4177  smallt **arr = &(self->a->data);
4178 
4179  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4180  arr[index+i] = arr[index+1 + i];
4181  }
4182 
4183  self->a->count--;
4184  }
4185 
4186  return(r);
4187 }
4188 
4189 internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index) {
4190 
4191  if (index >= (int64_t)lenSmallArray(self)) {
4192  return(0);
4193  }
4194  if (index < -(int64_t)lenSmallArray(self)) {
4195  return(0);
4196  }
4197  if (index < 0) {
4198  index = (int64_t)lenSmallArray(self) + index;
4199  }
4200 
4201  double r = 0;
4202  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4203  if (!o) {
4204  return(0);
4205  }
4206  smallDoublet *e = (smallDoublet*)toBaset(o);
4207  if (e) {
4208  if (checkObjectTypes && !isOSmallDouble(e)) {
4209  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4210  return(0);
4211  }
4212  finishO(e);
4213  return(0);
4214  }
4215  r = e->f->get(e);
4216  terminateO(e);
4217 
4218  // copy pointers from range index+1, array->count to index
4219  smallt **arr = &(self->a->data);
4220 
4221  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4222  arr[index+i] = arr[index+1 + i];
4223  }
4224 
4225  self->a->count--;
4226  }
4227 
4228  return(r);
4229 }
4230 
4231 internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index) {
4232 
4233  if (index >= (int64_t)lenSmallArray(self)) {
4234  return(0);
4235  }
4236  if (index < -(int64_t)lenSmallArray(self)) {
4237  return(0);
4238  }
4239  if (index < 0) {
4240  index = (int64_t)lenSmallArray(self) + index;
4241  }
4242 
4243  int64_t r = 0;
4244  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4245  if (!o) {
4246  return(0);
4247  }
4248  smallIntt *e = (smallIntt*)toBaset(o);
4249  if (e) {
4250  if (checkObjectTypes && !isOSmallInt(e)) {
4251  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4252  return(0);
4253  }
4254  finishO(e);
4255  return(0);
4256  }
4257  r = e->f->get(e);
4258  terminateO(e);
4259 
4260  // copy pointers from range index+1, array->count to index
4261  smallt **arr = &(self->a->data);
4262 
4263  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4264  arr[index+i] = arr[index+1 + i];
4265  }
4266 
4267  self->a->count--;
4268  }
4269 
4270  return(r);
4271 }
4272 
4273 
4274 internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index) {
4275 
4276  if (index >= (int64_t)lenSmallArray(self)) {
4277  return(0);
4278  }
4279  if (index < -(int64_t)lenSmallArray(self)) {
4280  return(0);
4281  }
4282  if (index < 0) {
4283  index = (int64_t)lenSmallArray(self) + index;
4284  }
4285 
4286  int32_t r = 0;
4287  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4288  if (!o) {
4289  return(0);
4290  }
4291  smallIntt *e = (smallIntt*)toBaset(o);
4292  if (e) {
4293  if (checkObjectTypes && !isOSmallInt(e)) {
4294  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4295  return(0);
4296  }
4297  finishO(e);
4298  return(0);
4299  }
4300  r = (int32_t)e->f->get(e);
4301  terminateO(e);
4302 
4303  // copy pointers from range index+1, array->count to index
4304  smallt **arr = &(self->a->data);
4305 
4306  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4307  arr[index+i] = arr[index+1 + i];
4308  }
4309 
4310  self->a->count--;
4311  }
4312 
4313  return(r);
4314 }
4315 
4316 internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index) {
4317 
4318  if (index >= (int64_t)lenSmallArray(self)) {
4319  return(0);
4320  }
4321  if (index < -(int64_t)lenSmallArray(self)) {
4322  return(0);
4323  }
4324  if (index < 0) {
4325  index = (int64_t)lenSmallArray(self) + index;
4326  }
4327 
4328  uint64_t r = 0;
4329  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4330  if (!o) {
4331  return(0);
4332  }
4333  smallIntt *e = (smallIntt*)toBaset(o);
4334  if (e) {
4335  if (checkObjectTypes && !isOSmallInt(e)) {
4336  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4337  return(0);
4338  }
4339  finishO(e);
4340  return(0);
4341  }
4342  r = (uint64_t)e->f->get(e);
4343  terminateO(e);
4344 
4345  // copy pointers from range index+1, array->count to index
4346  smallt **arr = &(self->a->data);
4347 
4348  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4349  arr[index+i] = arr[index+1 + i];
4350  }
4351 
4352  self->a->count--;
4353  }
4354 
4355  return(r);
4356 }
4357 
4358 internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index) {
4359 
4360  if (index >= (int64_t)lenSmallArray(self)) {
4361  return(0);
4362  }
4363  if (index < -(int64_t)lenSmallArray(self)) {
4364  return(0);
4365  }
4366  if (index < 0) {
4367  index = (int64_t)lenSmallArray(self) + index;
4368  }
4369 
4370  uint32_t r = 0;
4371  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4372  if (!o) {
4373  return(0);
4374  }
4375  smallIntt *e = (smallIntt*)toBaset(o);
4376  if (e) {
4377  if (checkObjectTypes && !isOSmallInt(e)) {
4378  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4379  return(0);
4380  }
4381  finishO(e);
4382  return(0);
4383  }
4384  r = (uint32_t)e->f->get(e);
4385  terminateO(e);
4386 
4387  // copy pointers from range index+1, array->count to index
4388  smallt **arr = &(self->a->data);
4389 
4390  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4391  arr[index+i] = arr[index+1 + i];
4392  }
4393 
4394  self->a->count--;
4395  }
4396 
4397  return(r);
4398 }
4399 
4400 internal char* cropElemSSmallArray(smallArrayt *self, int64_t index) {
4401 
4402  if (index >= (int64_t)lenSmallArray(self)) {
4403  return(NULL);
4404  }
4405  if (index < -(int64_t)lenSmallArray(self)) {
4406  return(NULL);
4407  }
4408  if (index < 0) {
4409  index = (int64_t)lenSmallArray(self) + index;
4410  }
4411 
4412  char *r = NULL;
4413  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4414  if (!o) {
4415  return(NULL);
4416  }
4417  smallStringt *e = (smallStringt*)toBaset(o);
4418  if (e) {
4419  if (checkObjectTypes && !isOSmallString(e)) {
4420  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4421  return(NULL);
4422  }
4423  finishO(e);
4424  return(NULL);
4425  }
4426  r = dupS(e->f->get(e));
4427  terminateO(e);
4428 
4429  // copy pointers from range index+1, array->count to index
4430  smallt **arr = &(self->a->data);
4431 
4432  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4433  arr[index+i] = arr[index+1 + i];
4434  }
4435 
4436  self->a->count--;
4437  }
4438 
4439  return(r);
4440 }
4441 
4442 internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index) {
4443 
4444  if (index >= (int64_t)lenSmallArray(self)) {
4445  return(NULL);
4446  }
4447  if (index < -(int64_t)lenSmallArray(self)) {
4448  return(NULL);
4449  }
4450  if (index < 0) {
4451  index = (int64_t)lenSmallArray(self) + index;
4452  }
4453 
4454  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4455  if (!o) {
4456  return(NULL);
4457  }
4458  smallDictt *r = (smallDictt*)toBaset(o);
4459  if (checkObjectTypes && r && !isOSmallDict(r)) {
4460  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4461  return(NULL);
4462  }
4463  finishO(r);
4464  return(NULL);
4465  }
4466 
4467  // copy pointers from range index+1, array->count to index
4468  smallt **arr = &(self->a->data);
4469 
4470  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4471  arr[index+i] = arr[index+1 + i];
4472  }
4473 
4474  self->a->count--;
4475 
4476  return(r);
4477 }
4478 
4479 internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index) {
4480 
4481  if (index >= (int64_t)lenSmallArray(self)) {
4482  return(NULL);
4483  }
4484  if (index < -(int64_t)lenSmallArray(self)) {
4485  return(NULL);
4486  }
4487  if (index < 0) {
4488  index = (int64_t)lenSmallArray(self) + index;
4489  }
4490 
4491  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4492  if (!o) {
4493  return(NULL);
4494  }
4495  smallArrayt *r = (smallArrayt*)toBaset(o);
4496  if (checkObjectTypes && r && !isOSmallArray(r)) {
4497  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4498  return(NULL);
4499  }
4500  finishO(r);
4501  return(NULL);
4502  }
4503 
4504  // copy pointers from range index+1, array->count to index
4505  smallt **arr = &(self->a->data);
4506 
4507  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4508  arr[index+i] = arr[index+1 + i];
4509  }
4510 
4511  self->a->count--;
4512 
4513  return(r);
4514 }
4515 
4516 internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index) {
4517 
4518  if (index >= (int64_t)lenSmallArray(self)) {
4519  return(NULL);
4520  }
4521  if (index < -(int64_t)lenSmallArray(self)) {
4522  return(NULL);
4523  }
4524  if (index < 0) {
4525  index = (int64_t)lenSmallArray(self) + index;
4526  }
4527 
4528  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4529  if (!o) {
4530  return(NULL);
4531  }
4532  smallBoolt *r = (smallBoolt*)toBaset(o);
4533  if (checkObjectTypes && r && !isOSmallBool(r)) {
4534  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4535  return(NULL);
4536  }
4537  finishO(r);
4538  return(NULL);
4539  }
4540 
4541  // copy pointers from range index+1, array->count to index
4542  smallt **arr = &(self->a->data);
4543 
4544  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4545  arr[index+i] = arr[index+1 + i];
4546  }
4547 
4548  self->a->count--;
4549 
4550  return(r);
4551 }
4552 
4553 internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index) {
4554 
4555  if (index >= (int64_t)lenSmallArray(self)) {
4556  return(NULL);
4557  }
4558  if (index < -(int64_t)lenSmallArray(self)) {
4559  return(NULL);
4560  }
4561  if (index < 0) {
4562  index = (int64_t)lenSmallArray(self) + index;
4563  }
4564 
4565  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4566  if (!o) {
4567  return(NULL);
4568  }
4569  smallBytest *r = (smallBytest*)toBaset(o);
4570  if (checkObjectTypes && r && !isOSmallBytes(r)) {
4571  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4572  return(NULL);
4573  }
4574  finishO(r);
4575  return(NULL);
4576  }
4577 
4578  // copy pointers from range index+1, array->count to index
4579  smallt **arr = &(self->a->data);
4580 
4581  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4582  arr[index+i] = arr[index+1 + i];
4583  }
4584 
4585  self->a->count--;
4586 
4587  return(r);
4588 }
4589 
4590 internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
4591 
4592  if (index >= (int64_t)lenSmallArray(self)) {
4593  return(NULL);
4594  }
4595  if (index < -(int64_t)lenSmallArray(self)) {
4596  return(NULL);
4597  }
4598  if (index < 0) {
4599  index = (int64_t)lenSmallArray(self) + index;
4600  }
4601 
4602  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4603  if (!o) {
4604  return(NULL);
4605  }
4606  smallDoublet *r = (smallDoublet*)toBaset(o);
4607  if (checkObjectTypes && r && !isOSmallDouble(r)) {
4608  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4609  return(NULL);
4610  }
4611  finishO(r);
4612  return(NULL);
4613  }
4614 
4615  // copy pointers from range index+1, array->count to index
4616  smallt **arr = &(self->a->data);
4617 
4618  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4619  arr[index+i] = arr[index+1 + i];
4620  }
4621 
4622  self->a->count--;
4623 
4624  return(r);
4625 }
4626 
4627 internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index) {
4628 
4629  if (index >= (int64_t)lenSmallArray(self)) {
4630  return(NULL);
4631  }
4632  if (index < -(int64_t)lenSmallArray(self)) {
4633  return(NULL);
4634  }
4635  if (index < 0) {
4636  index = (int64_t)lenSmallArray(self) + index;
4637  }
4638 
4639  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4640  if (!o) {
4641  return(NULL);
4642  }
4643  smallIntt *r = (smallIntt*)toBaset(o);
4644  if (checkObjectTypes && r && !isOSmallInt(r)) {
4645  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4646  return(NULL);
4647  }
4648  finishO(r);
4649  return(NULL);
4650  }
4651 
4652  // copy pointers from range index+1, array->count to index
4653  smallt **arr = &(self->a->data);
4654 
4655  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4656  arr[index+i] = arr[index+1 + i];
4657  }
4658 
4659  self->a->count--;
4660 
4661  return(r);
4662 }
4663 
4664 internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index) {
4665 
4666  if (index >= (int64_t)lenSmallArray(self)) {
4667  return(NULL);
4668  }
4669  if (index < -(int64_t)lenSmallArray(self)) {
4670  return(NULL);
4671  }
4672  if (index < 0) {
4673  index = (int64_t)lenSmallArray(self) + index;
4674  }
4675 
4676  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4677  if (!o) {
4678  return(NULL);
4679  }
4680  if ((o->type == BYTES) || (o->type == CONTAINER)) {
4681  return(NULL);
4682  }
4683  baset *e = toBaset(o);
4684  if (!e) {
4685  finishO(e);
4686  return(NULL);
4687  }
4688  createAllocateSmallJson(r);
4689  if (!r) {
4690  finishO(e);
4691  return(NULL);
4692  }
4693  setTopNFreeO(r, e);
4694 
4695  // copy pointers from range index+1, array->count to index
4696  smallt **arr = &(self->a->data);
4697 
4698  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4699  arr[index+i] = arr[index+1 + i];
4700  }
4701 
4702  self->a->count--;
4703 
4704  return(r);
4705 }
4706 
4707 internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index) {
4708 
4709  if (index >= (int64_t)lenSmallArray(self)) {
4710  return(NULL);
4711  }
4712  if (index < -(int64_t)lenSmallArray(self)) {
4713  return(NULL);
4714  }
4715  if (index < 0) {
4716  index = (int64_t)lenSmallArray(self) + index;
4717  }
4718 
4719  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4720  if (!o) {
4721  return(NULL);
4722  }
4723  smallStringt *r = (smallStringt*)toBaset(o);
4724  if (checkObjectTypes && r && !isOSmallString(r)) {
4725  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4726  return(NULL);
4727  }
4728  finishO(r);
4729  return(NULL);
4730  }
4731 
4732  // copy pointers from range index+1, array->count to index
4733  smallt **arr = &(self->a->data);
4734 
4735  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4736  arr[index+i] = arr[index+1 + i];
4737  }
4738 
4739  self->a->count--;
4740 
4741  return(r);
4742 }
4743 
4744 internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index) {
4745 
4746  if (index >= (int64_t)lenSmallArray(self)) {
4747  return(NULL);
4748  }
4749  if (index < -(int64_t)lenSmallArray(self)) {
4750  return(NULL);
4751  }
4752  if (index < 0) {
4753  index = (int64_t)lenSmallArray(self) + index;
4754  }
4755 
4756  void *r = NULL;
4757  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4758  if (!o) {
4759  return(NULL);
4760  }
4761  smallContainert *e = (smallContainert*)toBaset(o);
4762  if (e) {
4763  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4764  return(NULL);
4765  }
4766  if (checkObjectTypes && !isOSmallContainer(e)) {
4767  finishO(e);
4768  return(NULL);
4769  }
4770  r = e->f->get(e);
4771  smashO(e);
4772 
4773  // copy pointers from range index+1, array->count to index
4774  smallt **arr = &(self->a->data);
4775 
4776  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4777  arr[index+i] = arr[index+1 + i];
4778  }
4779 
4780  self->a->count--;
4781  }
4782 
4783  return(r);
4784 }
4785 
4786 internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index) {
4787 
4788  if (index >= (int64_t)lenSmallArray(self)) {
4789  return(NULL);
4790  }
4791  if (index < -(int64_t)lenSmallArray(self)) {
4792  return(NULL);
4793  }
4794  if (index < 0) {
4795  index = (int64_t)lenSmallArray(self) + index;
4796  }
4797 
4798  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
4799  if (!o) {
4800  return(NULL);
4801  }
4802  smallContainert *r = (smallContainert*)toBaset(o);
4803  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
4804  return(NULL);
4805  }
4806  if (checkObjectTypes && r && !isOSmallContainer(r)) {
4807  finishO(r);
4808  return(NULL);
4809  }
4810 
4811  // copy pointers from range index+1, array->count to index
4812  smallt **arr = &(self->a->data);
4813 
4814  for (uint32_t i = 0 ; i < (self->a->count - (index+1)) ; i ++) {
4815  arr[index+i] = arr[index+1 + i];
4816  }
4817 
4818  self->a->count--;
4819 
4820  return(r);
4821 }
4822 
4823 internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end) {
4824  size_t len;
4825  smallt *o = NULL;
4826 
4827  len = lenSmallArray(self);
4828  // sanity checks
4829  if (!len) {
4830  return(NULL);
4831  }
4832 
4833  if (start >= (int64_t)len) {
4834  return(NULL);
4835  }
4836  if (end > (int64_t)len) {
4837  end = (int64_t)len;
4838  }
4839  if (start <= -(int64_t)len) {
4840  start = -(int64_t)len;
4841  }
4842  if (end <= -(int64_t)len) {
4843  return(NULL);
4844  }
4845  if (start < 0) {
4846  start = (int64_t)len + start;
4847  }
4848  if (end <= 0) {
4849  end = (int64_t)len + end;
4850  }
4851  if (end < start) {
4852  return(NULL);
4853  }
4854 
4855  createAllocateSmallArray(r);
4856  if (!r) {
4857  return(NULL);
4858  }
4859 
4860  if (start == end) {
4861  // empty list
4862  return(r);
4863  }
4864  else {
4865  // start < end < len
4866  int64_t n;
4867  n = end - start;
4868 
4869  for (int64_t i=0;i < n;i++) {
4870  o = sArrayGetTiny(self->a, (uint32_t)(start+i));
4871  sArrayPushTiny(&(r->a), sDuplicate(o));
4872  }
4873  }
4874 
4875  return(r);
4876 }
4877 
4878 internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
4879  size_t len;;
4880 
4881  //sanity checks
4882  if (checkObjectTypes && toInsert && !isOSmallArray(toInsert)) {
4883  return(NULL);
4884  }
4885 
4886  if (!toInsert) {
4887  return(NULL);
4888  }
4889 
4890  if (self->a == toInsert->a) {
4891  return(NULL);
4892  }
4893 
4894  len = lenSmallArray(self);
4895 
4896  if (!len && index == -1) {
4897  // empty array, index -1 is equal to 0
4898  index = 0;
4899  }
4900  bool neg = false;
4901  if (index < 0) {
4902  neg = true;
4903  }
4904 
4905  if (index > (int64_t)len) {
4906  return(NULL);
4907  }
4908  if (neg) {
4909  index++;
4910  }
4911  if (index < -(int64_t)len) {
4912  return(NULL);
4913  }
4914  if (neg) {
4915  index = (int64_t)len + index;
4916  }
4917 
4918 
4919  if (!toInsert->f->len(toInsert)) {
4920  return(self);
4921  }
4922 
4923  sArrayt *a = allocSArray();
4924  if (!a) {
4925  return(NULL);
4926  }
4927 
4928  smallt *o;
4929  if (index == 0) {
4930  // insert at beginning
4931  for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
4932  o = sArrayGetTiny(toInsert->a, (uint32_t)i);
4933  sArrayPushTiny(&a, o);
4934  }
4935  for (int64_t i=0;i < (int64_t)len;i++) {
4936  o = sArrayGetTiny(self->a, (uint32_t)i);
4937  sArrayPushTiny(&a, o);
4938  }
4939  }
4940  else {
4941 
4942  for (int64_t i=0;i < index;i++) {
4943  o = sArrayGetTiny(self->a, (uint32_t)i);
4944  sArrayPushTiny(&a, o);
4945  }
4946  for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
4947  o = sArrayGetTiny(toInsert->a, (uint32_t)i);
4948  sArrayPushTiny(&a, o);
4949  }
4950  for (int64_t i=index;i < (int64_t)len;i++) {
4951  o = sArrayGetTiny(self->a, (uint32_t)i);
4952  sArrayPushTiny(&a, o);
4953  }
4954  }
4955 
4956  free(self->a);
4957  self->a = a;
4958  return(self);
4959 }
4960 
4961 internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) {
4962 
4963  if (!toInsert) {
4964  return(NULL);
4965  }
4966 
4967  if (checkObjectTypes && !isOSmallJson(toInsert)) {
4968  return(NULL);
4969  }
4970 
4971  const char *type = getTopTypeO(toInsert);
4972 
4973  if (!eqS(type,"array")) {
4974  return(NULL);
4975  }
4976 
4977  if (!lenO(toInsert)) {
4978  return(self);
4979  }
4980 
4981  createSmallArray(a);
4982  if (!a.f) {
4983  return(NULL);
4984  }
4985  setsoO(&a, (sArrayt*)getsoO(toInsert));
4986  return(insertSmallArray(self, index, &a));
4987 }
4988 
4989 internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
4990  smallArrayt *r = NULL;
4991 
4992  r = insertSmallArray(self, index, toInsert);
4993  if (r) {
4994  smashO(toInsert);
4995  }
4996  return(r);
4997 }
4998 
4999 internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) {
5000  smallArrayt *r = NULL;
5001 
5002  r = insertSmallJsonSmallArray(self, index, toInsert);
5003  if (r) {
5004  smashO(toInsert);
5005  }
5006  return(r);
5007 }
5008 
5009 
5010 internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject) {
5011  size_t len;
5012 
5013  if (!toInject) {
5014  return(NULL);
5015  }
5016 
5017  len = lenSmallArray(self);
5018 
5019  if (!len && index == -1) {
5020  // empty string, index -1 is equal to 0
5021  index = 0;
5022  }
5023  bool neg = false;
5024  if (index < 0) {
5025  neg = true;
5026  }
5027 
5028  if (index > (int64_t)len) {
5029  return(NULL);
5030  }
5031  if (neg) {
5032  index++;
5033  }
5034  if (index < -(int64_t)len) {
5035  return(NULL);
5036  }
5037  if (neg) {
5038  index = (int64_t)len + index;
5039  }
5040 
5041 
5042  sArrayt *a = allocSArray();
5043  if (!a) {
5044  return(NULL);
5045  }
5046 
5047  smallt *o = toSmallt(toInject);
5048  if (!o) {
5049  sFree((smallt*)a);
5050  return(NULL);
5051  }
5052 
5053  if (index == 0) {
5054  // inject at beginning
5055  sArrayPushTiny(&a, o);
5056  for (int64_t i=0;i < (int64_t)len;i++) {
5057  o = sArrayGetTiny(self->a, (uint32_t)i);
5058  sArrayPushTiny(&a, o);
5059  }
5060  }
5061  else {
5062 
5063  smallt *o2;
5064  for (int64_t i=0;i < index;i++) {
5065  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5066  sArrayPushTiny(&a, o2);
5067  }
5068  sArrayPushTiny(&a, o);
5069  for (int64_t i=index;i < (int64_t)len;i++) {
5070  o = sArrayGetTiny(self->a, (uint32_t)i);
5071  sArrayPushTiny(&a, o);
5072  }
5073  }
5074 
5075  free(self->a);
5076  self->a = a;
5077  return(self);
5078 }
5079 
5080 internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index) {
5081  size_t len;
5082 
5083  len = lenSmallArray(self);
5084 
5085  if (!len && index == -1) {
5086  // empty string, index -1 is equal to 0
5087  index = 0;
5088  }
5089  bool neg = false;
5090  if (index < 0) {
5091  neg = true;
5092  }
5093 
5094  if (index > (int64_t)len) {
5095  return(NULL);
5096  }
5097  if (neg) {
5098  index++;
5099  }
5100  if (index < -(int64_t)len) {
5101  return(NULL);
5102  }
5103  if (neg) {
5104  index = (int64_t)len + index;
5105  }
5106 
5107 
5108  sArrayt *a = allocSArray();
5109  if (!a) {
5110  return(NULL);
5111  }
5112 
5113  smallt *o = (smallt *) allocSUndefined();
5114 
5115  if (index == 0) {
5116  // inject at beginning
5117  sArrayPushTiny(&a, o);
5118  for (int64_t i=0;i < (int64_t)len;i++) {
5119  o = sArrayGetTiny(self->a, (uint32_t)i);
5120  sArrayPushTiny(&a, o);
5121  }
5122  }
5123  else {
5124 
5125  smallt *o2;
5126  for (int64_t i=0;i < index;i++) {
5127  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5128  sArrayPushTiny(&a, o2);
5129  }
5130  sArrayPushTiny(&a, o);
5131  for (int64_t i=index;i < (int64_t)len;i++) {
5132  o = sArrayGetTiny(self->a, (uint32_t)i);
5133  sArrayPushTiny(&a, o);
5134  }
5135  }
5136 
5137  free(self->a);
5138  self->a = a;
5139  return(self);
5140 }
5141 
5142 internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject) {
5143  size_t len;
5144 
5145  len = lenSmallArray(self);
5146 
5147  if (!len && index == -1) {
5148  // empty string, index -1 is equal to 0
5149  index = 0;
5150  }
5151  bool neg = false;
5152  if (index < 0) {
5153  neg = true;
5154  }
5155 
5156  if (index > (int64_t)len) {
5157  return(NULL);
5158  }
5159  if (neg) {
5160  index++;
5161  }
5162  if (index < -(int64_t)len) {
5163  return(NULL);
5164  }
5165  if (neg) {
5166  index = (int64_t)len + index;
5167  }
5168 
5169 
5170  sArrayt *a = allocSArray();
5171  if (!a) {
5172  return(NULL);
5173  }
5174 
5175  smallt *o = NULL;
5176  o = (smallt *) allocSBool(toInject);
5177 
5178  if (index == 0) {
5179  // inject at beginning
5180  sArrayPushTiny(&a, o);
5181  for (int64_t i=0;i < (int64_t)len;i++) {
5182  o = sArrayGetTiny(self->a, (uint32_t)i);
5183  sArrayPushTiny(&a, o);
5184  }
5185  }
5186  else {
5187 
5188  smallt *o2;
5189  for (int64_t i=0;i < index;i++) {
5190  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5191  sArrayPushTiny(&a, o2);
5192  }
5193  sArrayPushTiny(&a, o);
5194  for (int64_t i=index;i < (int64_t)len;i++) {
5195  o = sArrayGetTiny(self->a, (uint32_t)i);
5196  sArrayPushTiny(&a, o);
5197  }
5198  }
5199 
5200  free(self->a);
5201  self->a = a;
5202  return(self);
5203 }
5204 
5205 internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject) {
5206  size_t len;
5207 
5208  len = lenSmallArray(self);
5209 
5210  if (!len && index == -1) {
5211  // empty string, index -1 is equal to 0
5212  index = 0;
5213  }
5214  bool neg = false;
5215  if (index < 0) {
5216  neg = true;
5217  }
5218 
5219  if (index > (int64_t)len) {
5220  return(NULL);
5221  }
5222  if (neg) {
5223  index++;
5224  }
5225  if (index < -(int64_t)len) {
5226  return(NULL);
5227  }
5228  if (neg) {
5229  index = (int64_t)len + index;
5230  }
5231 
5232 
5233  sArrayt *a = allocSArray();
5234  if (!a) {
5235  return(NULL);
5236  }
5237 
5238  smallt *o = NULL;
5239  o = (smallt *) allocSDouble(toInject);
5240 
5241  if (index == 0) {
5242  // inject at beginning
5243  sArrayPushTiny(&a, o);
5244  for (int64_t i=0;i < (int64_t)len;i++) {
5245  o = sArrayGetTiny(self->a, (uint32_t)i);
5246  sArrayPushTiny(&a, o);
5247  }
5248  }
5249  else {
5250 
5251  smallt *o2;
5252  for (int64_t i=0;i < index;i++) {
5253  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5254  sArrayPushTiny(&a, o2);
5255  }
5256  sArrayPushTiny(&a, o);
5257  for (int64_t i=index;i < (int64_t)len;i++) {
5258  o = sArrayGetTiny(self->a, (uint32_t)i);
5259  sArrayPushTiny(&a, o);
5260  }
5261  }
5262 
5263  free(self->a);
5264  self->a = a;
5265  return(self);
5266 }
5267 
5268 internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject) {
5269  size_t len;
5270 
5271  len = lenSmallArray(self);
5272 
5273  if (!len && index == -1) {
5274  // empty string, index -1 is equal to 0
5275  index = 0;
5276  }
5277  bool neg = false;
5278  if (index < 0) {
5279  neg = true;
5280  }
5281 
5282  if (index > (int64_t)len) {
5283  return(NULL);
5284  }
5285  if (neg) {
5286  index++;
5287  }
5288  if (index < -(int64_t)len) {
5289  return(NULL);
5290  }
5291  if (neg) {
5292  index = (int64_t)len + index;
5293  }
5294 
5295 
5296  sArrayt *a = allocSArray();
5297  if (!a) {
5298  return(NULL);
5299  }
5300 
5301  smallt *o = NULL;
5302  o = (smallt *) allocSInt(toInject);
5303 
5304  if (index == 0) {
5305  // inject at beginning
5306  sArrayPushTiny(&a, o);
5307  for (int64_t i=0;i < (int64_t)len;i++) {
5308  o = sArrayGetTiny(self->a, (uint32_t)i);
5309  sArrayPushTiny(&a, o);
5310  }
5311  }
5312  else {
5313 
5314  smallt *o2;
5315  for (int64_t i=0;i < index;i++) {
5316  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5317  sArrayPushTiny(&a, o2);
5318  }
5319  sArrayPushTiny(&a, o);
5320  for (int64_t i=index;i < (int64_t)len;i++) {
5321  o = sArrayGetTiny(self->a, (uint32_t)i);
5322  sArrayPushTiny(&a, o);
5323  }
5324  }
5325 
5326  free(self->a);
5327  self->a = a;
5328  return(self);
5329 }
5330 
5331 internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject) {
5332  size_t len;
5333 
5334  if (!toInject) {
5335  return(NULL);
5336  }
5337 
5338  len = lenSmallArray(self);
5339 
5340  if (!len && index == -1) {
5341  // empty string, index -1 is equal to 0
5342  index = 0;
5343  }
5344  bool neg = false;
5345  if (index < 0) {
5346  neg = true;
5347  }
5348 
5349  if (index > (int64_t)len) {
5350  return(NULL);
5351  }
5352  if (neg) {
5353  index++;
5354  }
5355  if (index < -(int64_t)len) {
5356  return(NULL);
5357  }
5358  if (neg) {
5359  index = (int64_t)len + index;
5360  }
5361 
5362 
5363  sArrayt *a = allocSArray();
5364  if (!a) {
5365  return(NULL);
5366  }
5367 
5368  smallt *o = (smallt *) allocSStringTiny(toInject);
5369 
5370  if (index == 0) {
5371  // inject at beginning
5372  sArrayPushTiny(&a, o);
5373  for (int64_t i=0;i < (int64_t)len;i++) {
5374  o = sArrayGetTiny(self->a, (uint32_t)i);
5375  sArrayPushTiny(&a, o);
5376  }
5377  }
5378  else {
5379 
5380  smallt *o2;
5381  for (int64_t i=0;i < index;i++) {
5382  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5383  sArrayPushTiny(&a, o2);
5384  }
5385  sArrayPushTiny(&a, o);
5386  for (int64_t i=index;i < (int64_t)len;i++) {
5387  o = sArrayGetTiny(self->a, (uint32_t)i);
5388  sArrayPushTiny(&a, o);
5389  }
5390  }
5391 
5392  free(self->a);
5393  self->a = a;
5394  return(self);
5395 }
5396 
5397 internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c) {
5398 
5399  charToS(s, c);
5400  return(injectSSmallArray(self, index, s));
5401 }
5402 
5403 internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) {
5404  size_t len;
5405 
5406  if (!toInject) {
5407  return(NULL);
5408  }
5409 
5410  if (checkObjectTypes && toInject && !isOSmallDict(toInject)) {
5411  return(NULL);
5412  }
5413 
5414  len = lenSmallArray(self);
5415 
5416  if (!len && index == -1) {
5417  // empty string, index -1 is equal to 0
5418  index = 0;
5419  }
5420  bool neg = false;
5421  if (index < 0) {
5422  neg = true;
5423  }
5424 
5425  if (index > (int64_t)len) {
5426  return(NULL);
5427  }
5428  if (neg) {
5429  index++;
5430  }
5431  if (index < -(int64_t)len) {
5432  return(NULL);
5433  }
5434  if (neg) {
5435  index = (int64_t)len + index;
5436  }
5437 
5438 
5439  sArrayt *a = allocSArray();
5440  if (!a) {
5441  return(NULL);
5442  }
5443 
5444  if (!toInject->d) {
5445  isError(toInject->d, allocSDict()) return(NULL);
5446  }
5447 
5448  smallt *o = (smallt *) toInject->d;
5449 
5450  if (index == 0) {
5451  // inject at beginning
5452  sArrayPushTiny(&a, o);
5453  for (int64_t i=0;i < (int64_t)len;i++) {
5454  o = sArrayGetTiny(self->a, (uint32_t)i);
5455  sArrayPushTiny(&a, o);
5456  }
5457  }
5458  else {
5459 
5460  smallt *o2;
5461  for (int64_t i=0;i < index;i++) {
5462  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5463  sArrayPushTiny(&a, o2);
5464  }
5465  sArrayPushTiny(&a, o);
5466  for (int64_t i=index;i < (int64_t)len;i++) {
5467  o = sArrayGetTiny(self->a, (uint32_t)i);
5468  sArrayPushTiny(&a, o);
5469  }
5470  }
5471 
5472  free(self->a);
5473  self->a = a;
5474  return(self);
5475 }
5476 
5477 internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) {
5478  size_t len;
5479 
5480  if (!toInject) {
5481  return(NULL);
5482  }
5483 
5484  if (checkObjectTypes && toInject && !isOSmallArray(toInject)) {
5485  return(NULL);
5486  }
5487 
5488  len = lenSmallArray(self);
5489 
5490  if (!len && index == -1) {
5491  // empty string, index -1 is equal to 0
5492  index = 0;
5493  }
5494  bool neg = false;
5495  if (index < 0) {
5496  neg = true;
5497  }
5498 
5499  if (index > (int64_t)len) {
5500  return(NULL);
5501  }
5502  if (neg) {
5503  index++;
5504  }
5505  if (index < -(int64_t)len) {
5506  return(NULL);
5507  }
5508  if (neg) {
5509  index = (int64_t)len + index;
5510  }
5511 
5512 
5513  sArrayt *a = allocSArray();
5514  if (!a) {
5515  return(NULL);
5516  }
5517 
5518  if (!toInject->a) {
5519  isError(toInject->a, allocSArray()) return(NULL);
5520  }
5521 
5522  smallt *o = (smallt *) toInject->a;
5523 
5524  if (index == 0) {
5525  // inject at beginning
5526  sArrayPushTiny(&a, o);
5527  for (int64_t i=0;i < (int64_t)len;i++) {
5528  o = sArrayGetTiny(self->a, (uint32_t)i);
5529  sArrayPushTiny(&a, o);
5530  }
5531  }
5532  else {
5533 
5534  smallt *o2;
5535  for (int64_t i=0;i < index;i++) {
5536  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5537  sArrayPushTiny(&a, o2);
5538  }
5539  sArrayPushTiny(&a, o);
5540  for (int64_t i=index;i < (int64_t)len;i++) {
5541  o = sArrayGetTiny(self->a, (uint32_t)i);
5542  sArrayPushTiny(&a, o);
5543  }
5544  }
5545 
5546  free(self->a);
5547  self->a = a;
5548  return(self);
5549 }
5550 
5551 internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) {
5552  size_t len;
5553 
5554  if (!toInject) {
5555  return(NULL);
5556  }
5557 
5558  len = lenSmallArray(self);
5559 
5560  if (!len && index == -1) {
5561  // empty string, index -1 is equal to 0
5562  index = 0;
5563  }
5564  bool neg = false;
5565  if (index < 0) {
5566  neg = true;
5567  }
5568 
5569  if (index > (int64_t)len) {
5570  return(NULL);
5571  }
5572  if (neg) {
5573  index++;
5574  }
5575  if (index < -(int64_t)len) {
5576  return(NULL);
5577  }
5578  if (neg) {
5579  index = (int64_t)len + index;
5580  }
5581 
5582 
5583  sArrayt *a = allocSArray();
5584  if (!a) {
5585  return(NULL);
5586  }
5587 
5588  smallt *o = NULL;
5589  sArrayt *aa = allocSArray();
5590 
5591  forEachCharP(toInject, e) {
5592  sStringt *s = allocSStringTiny(*e);
5593  if (!s) {
5594  if (a) {
5595  sArrayFreeTiny(a);
5596  }
5597  if (aa) {
5598  sArrayFreeTiny(aa);
5599  }
5600  return(NULL);
5601  }
5602  sArrayPushTiny(&aa, (smallt *) s);
5603  }
5604  o = (smallt *) aa;
5605 
5606  if (index == 0) {
5607  // inject at beginning
5608  sArrayPushTiny(&a, o);
5609  for (int64_t i=0;i < (int64_t)len;i++) {
5610  o = sArrayGetTiny(self->a, (uint32_t)i);
5611  sArrayPushTiny(&a, o);
5612  }
5613  }
5614  else {
5615 
5616  smallt *o2;
5617  for (int64_t i=0;i < index;i++) {
5618  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5619  sArrayPushTiny(&a, o2);
5620  }
5621  sArrayPushTiny(&a, o);
5622  for (int64_t i=index;i < (int64_t)len;i++) {
5623  o = sArrayGetTiny(self->a, (uint32_t)i);
5624  sArrayPushTiny(&a, o);
5625  }
5626  }
5627 
5628  free(self->a);
5629  self->a = a;
5630  return(self);
5631 }
5632 
5633 internal smallArrayt* injectCArraycSmallArray(smallArrayt *self, int64_t index, const char **toInject) {
5634  size_t len;
5635 
5636  if (!toInject) {
5637  return(NULL);
5638  }
5639 
5640  len = lenSmallArray(self);
5641 
5642  if (!len && index == -1) {
5643  // empty string, index -1 is equal to 0
5644  index = 0;
5645  }
5646  bool neg = false;
5647  if (index < 0) {
5648  neg = true;
5649  }
5650 
5651  if (index > (int64_t)len) {
5652  return(NULL);
5653  }
5654  if (neg) {
5655  index++;
5656  }
5657  if (index < -(int64_t)len) {
5658  return(NULL);
5659  }
5660  if (neg) {
5661  index = (int64_t)len + index;
5662  }
5663 
5664 
5665  sArrayt *a = allocSArray();
5666  if (!a) {
5667  return(NULL);
5668  }
5669 
5670  smallt *o = NULL;
5671  sArrayt *aa = allocSArray();
5672 
5673  forEachCCharP(toInject, e) {
5674  sStringt *s = allocSStringTiny(*e);
5675  if (!s) {
5676  if (a) {
5677  sArrayFreeTiny(a);
5678  }
5679  if (aa) {
5680  sArrayFreeTiny(aa);
5681  }
5682  return(NULL);
5683  }
5684  sArrayPushTiny(&aa, (smallt *) s);
5685  }
5686  o = (smallt *) aa;
5687 
5688  if (index == 0) {
5689  // inject at beginning
5690  sArrayPushTiny(&a, o);
5691  for (int64_t i=0;i < (int64_t)len;i++) {
5692  o = sArrayGetTiny(self->a, (uint32_t)i);
5693  sArrayPushTiny(&a, o);
5694  }
5695  }
5696  else {
5697 
5698  smallt *o2;
5699  for (int64_t i=0;i < index;i++) {
5700  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5701  sArrayPushTiny(&a, o2);
5702  }
5703  sArrayPushTiny(&a, o);
5704  for (int64_t i=index;i < (int64_t)len;i++) {
5705  o = sArrayGetTiny(self->a, (uint32_t)i);
5706  sArrayPushTiny(&a, o);
5707  }
5708  }
5709 
5710  free(self->a);
5711  self->a = a;
5712  return(self);
5713 }
5714 
5715 internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) {
5716 
5717  if (!toInject) {
5718  return(NULL);
5719  }
5720 
5721  if (checkObjectTypes && toInject && !isOSmallBool(toInject)) {
5722  return(NULL);
5723  }
5724 
5725  if (!toInject->value) {
5726  isError(toInject->value, allocSBool(false)) return(NULL);
5727  }
5728 
5729  return(injectSmallArray(self, index, (baset*)toInject));
5730 }
5731 
5732 internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) {
5733 
5734  if (!toInject) {
5735  return(NULL);
5736  }
5737 
5738  if (checkObjectTypes && toInject && !isOSmallBytes(toInject)) {
5739  return(NULL);
5740  }
5741 
5742  if (!toInject->B) {
5743  isError(toInject->B, allocSBytes()) return(NULL);
5744  }
5745 
5746  return(injectSmallArray(self, index, (baset*)toInject));
5747 }
5748 
5749 internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) {
5750 
5751  if (!toInject) {
5752  return(NULL);
5753  }
5754 
5755  if (checkObjectTypes && toInject && !isOSmallDouble(toInject)) {
5756  return(NULL);
5757  }
5758 
5759  if (!toInject->value) {
5760  isError(toInject->value, allocSDouble(0)) return(NULL);
5761  }
5762 
5763  return(injectSmallArray(self, index, (baset*)toInject));
5764 }
5765 
5766 internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) {
5767 
5768  if (!toInject) {
5769  return(NULL);
5770  }
5771 
5772  if (checkObjectTypes && toInject && !isOSmallInt(toInject)) {
5773  return(NULL);
5774  }
5775 
5776  if (!toInject->value) {
5777  isError(toInject->value, allocSInt(0)) return(NULL);
5778  }
5779 
5780  return(injectSmallArray(self, index, (baset*)toInject));
5781 }
5782 
5783 internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) {
5784 
5785  if (!toInject) {
5786  return(NULL);
5787  }
5788 
5789  if (checkObjectTypes && toInject && !isOSmallJson(toInject)) {
5790  return(NULL);
5791  }
5792 
5793  smallt *o = getsoO(toInject);
5794  if (!o) {
5795  // smallJson is empty, create an empty dict
5796  isError(o, (smallt*)allocSDict()) return(NULL);
5797  setsoO(toInject, o);
5798  }
5799 
5800  baset *O = getTopO(toInject);
5801 
5802  smallArrayt *r = injectSmallArray(self, index, O);
5803  finishO(O);
5804  return(r);
5805 }
5806 
5807 internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) {
5808 
5809  if (!toInject) {
5810  return(NULL);
5811  }
5812 
5813  if (checkObjectTypes && toInject && !isOSmallString(toInject)) {
5814  return(NULL);
5815  }
5816 
5817  if (!toInject->data) {
5818  isError(toInject->data, allocSStringTiny("")) return(NULL);
5819  }
5820 
5821  return(injectSmallArray(self, index, (baset*)toInject));
5822 }
5823 
5824 internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) {
5825 
5826  if (!toInject) {
5827  return(NULL);
5828  }
5829 
5830  if (checkObjectTypes && toInject && !isOSmallContainer(toInject)) {
5831  return(NULL);
5832  }
5833 
5834  if (!toInject->data) {
5835  isError(toInject->data, allocSContainer(NULL)) return(NULL);
5836  }
5837 
5838  return(injectSmallArray(self, index, (baset*)toInject));
5839 }
5840 
5841 internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject) {
5842  size_t len;
5843 
5844  if (!toInject) {
5845  return(NULL);
5846  }
5847 
5848  len = lenSmallArray(self);
5849 
5850  if (!len && index == -1) {
5851  // empty string, index -1 is equal to 0
5852  index = 0;
5853  }
5854  bool neg = false;
5855  if (index < 0) {
5856  neg = true;
5857  }
5858 
5859  if (index > (int64_t)len) {
5860  return(NULL);
5861  }
5862  if (neg) {
5863  index++;
5864  }
5865  if (index < -(int64_t)len) {
5866  return(NULL);
5867  }
5868  if (neg) {
5869  index = (int64_t)len + index;
5870  }
5871 
5872 
5873  sArrayt *a = allocSArray();
5874  if (!a) {
5875  return(NULL);
5876  }
5877 
5878  smallt *o = toSmallt(toInject);
5879  if (!o) {
5880  sFree((smallt*)a);
5881  return(NULL);
5882  }
5883 
5884  if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) {
5885  finishO(toInject);
5886  }
5887 
5888  if (index == 0) {
5889  // inject at beginning
5890  sArrayPushTiny(&a, o);
5891  for (int64_t i=0;i < (int64_t)len;i++) {
5892  o = sArrayGetTiny(self->a, (uint32_t)i);
5893  sArrayPushTiny(&a, o);
5894  }
5895  }
5896  else {
5897 
5898  smallt *o2;
5899  for (int64_t i=0;i < index;i++) {
5900  o2 = sArrayGetTiny(self->a, (uint32_t)i);
5901  sArrayPushTiny(&a, o2);
5902  }
5903  sArrayPushTiny(&a, o);
5904  for (int64_t i=index;i < (int64_t)len;i++) {
5905  o = sArrayGetTiny(self->a, (uint32_t)i);
5906  sArrayPushTiny(&a, o);
5907  }
5908  }
5909 
5910  free(self->a);
5911  self->a = a;
5912 
5913  return(self);
5914 }
5915 
5916 internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u) {
5917 
5918  smallArrayt *r = injectUndefinedSmallArray(self, index);
5919  if (r) {
5920  terminateO(u);
5921  }
5922  return(r);
5923 }
5924 
5925 internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject) {
5926 
5927  smallArrayt *r = injectSSmallArray(self, index, toInject);
5928  if (r) {
5929  free(toInject);
5930  }
5931  return(r);
5932 }
5933 
5934 internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) {
5935 
5936  smallArrayt *r = injectDictSmallArray(self, index, toInject);
5937  if (r) {
5938  finishO(toInject);
5939  }
5940  return(r);
5941 }
5942 
5943 internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) {
5944 
5945  smallArrayt *r = injectArraySmallArray(self, index, toInject);
5946  if (r) {
5947  finishO(toInject);
5948  }
5949  return(r);
5950 }
5951 
5952 internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) {
5953 
5954  smallArrayt *r = injectArraycSmallArray(self, index, toInject);
5955  if (r) {
5956  listFreeS(toInject);
5957  }
5958  return(r);
5959 }
5960 
5961 internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) {
5962 
5963  smallArrayt *r = injectSmallBoolSmallArray(self, index, toInject);
5964  if (r) {
5965  finishO(toInject);
5966  }
5967  return(r);
5968 }
5969 
5970 internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) {
5971 
5972  smallArrayt *r = injectSmallBytesSmallArray(self, index, toInject);
5973  if (r) {
5974  finishO(toInject);
5975  }
5976  return(r);
5977 }
5978 
5979 internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) {
5980 
5981  smallArrayt *r = injectSmallDoubleSmallArray(self, index, toInject);
5982  if (r) {
5983  finishO(toInject);
5984  }
5985  return(r);
5986 }
5987 
5988 internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) {
5989 
5990  smallArrayt *r = injectSmallIntSmallArray(self, index, toInject);
5991  if (r) {
5992  finishO(toInject);
5993  }
5994  return(r);
5995 }
5996 
5997 internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) {
5998 
5999  smallArrayt *r = injectSmallJsonSmallArray(self, index, toInject);
6000  if (r) {
6001  finishO(toInject);
6002  }
6003  return(r);
6004 }
6005 
6006 internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) {
6007 
6008  smallArrayt *r = injectSmallStringSmallArray(self, index, toInject);
6009  if (r) {
6010  finishO(toInject);
6011  }
6012  return(r);
6013 }
6014 
6015 internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) {
6016 
6017  smallArrayt *r = injectSmallContainerSmallArray(self, index, toInject);
6018  if (r) {
6019  finishO(toInject);
6020  }
6021  return(r);
6022 }
6023 
6024 internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end) {
6025  size_t len;;
6026 
6027  len = lenSmallArray(self);
6028 
6029  // sanity checks
6030  if (len == 0) {
6031  return(NULL);
6032  }
6033 
6034  if (start >= (int64_t)len) {
6035  start = (int64_t)len;
6036  }
6037  if (end > (int64_t)len) {
6038  end = (int64_t)len;
6039  }
6040  if (start <= -(int64_t)len) {
6041  start = -(int64_t)len;
6042  }
6043  if (end <= -(int64_t)len) {
6044  end = -(int64_t)len;
6045  }
6046  if (start < 0) {
6047  start = (int64_t)len + start;
6048  }
6049  if (end <= 0) {
6050  end = (int64_t)len + end;
6051  }
6052  if (end < start) {
6053  return(NULL);
6054  }
6055 
6056  if (start == end) {
6057  return(self);
6058  }
6059 
6060  // start < end < len
6061  sArrayDelRangeTiny(self->a, (uint32_t)start, (uint32_t)end);
6062 
6063  return(self);
6064 }
6065 
6066 internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index) {
6067  size_t len;;
6068 
6069  len = lenSmallArray(self);
6070 
6071  if (index >= (int64_t)len) {
6072  return(NULL);
6073  }
6074  if (index < -(int64_t)len) {
6075  return(NULL);
6076  }
6077  if (index < 0) {
6078  index = (int64_t)len + index;
6079  }
6080 
6081  sArrayDelTiny(self->a, (uint32_t)index);
6082  return(self);
6083 }
6084 
6085 internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end) {
6086  size_t len;;
6087 
6088  len = lenSmallArray(self);
6089 
6090  // sanity checks
6091  if (len == 0) {
6092  return(NULL);
6093  }
6094 
6095  if (start >= (int64_t)len) {
6096  start = (int64_t)len;
6097  }
6098  if (end > (int64_t)len) {
6099  end = (int64_t)len;
6100  }
6101  if (start <= -(int64_t)len) {
6102  start = -(int64_t)len;
6103  }
6104  if (end <= -(int64_t)len) {
6105  end = -(int64_t)len;
6106  }
6107  if (start < 0) {
6108  start = (int64_t)len + start;
6109  }
6110  if (end <= 0) {
6111  end = (int64_t)len + end;
6112  }
6113  if (end < start) {
6114  return(NULL);
6115  }
6116 
6117  if (start == end) {
6118  return(self);
6119  }
6120 
6121  // start < end < len
6122  for (uint32_t i = (uint32_t)start ; i < end ; i++) {
6123  sArraySetShortTiny(self->a, i, NULL);
6124  }
6125 
6126  return(self);
6127 }
6128 
6129 internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index) {
6130  size_t len;;
6131 
6132  len = lenSmallArray(self);
6133 
6134  if (index >= (int64_t)len) {
6135  return(NULL);
6136  }
6137  if (index < -(int64_t)len) {
6138  return(NULL);
6139  }
6140  if (index < 0) {
6141  index = (int64_t)len + index;
6142  }
6143 
6144  sArraySetShortTiny(self->a, (uint32_t)index, NULL);
6145  return(self);
6146 }
6147 
6148 internal int sortSCmp(const void * a, const void * b) {
6149 
6150  // sanity checks
6151  smallt *A = (*((smallt *const*)a));
6152  smallt *B = (*((smallt *const*)b));
6153  if (!A && !B) {
6154  return(0);
6155  }
6156  if (!A && B) {
6157  return(-1);
6158  }
6159  if (A && !B) {
6160  return(1);
6161  }
6162  char *As, *Bs;
6163  int r;
6164  if (A->type != B->type) {
6165  return(A->type - B->type);
6166  }
6167  else {
6168  switch (A->type){
6169  case UNDEFINED:
6170  return(0);
6171  case BOOL:
6172  return((((sBoolt*)A)->value < ((sBoolt*)B)->value) * -1);
6173  case CONTAINER:
6174  return(0);
6175  case DICT:
6176  if (((sDictt*)A)->count < ((sDictt*)B)->count) {
6177  return(-1);
6178  }
6179  else if (((sDictt*)A)->count == ((sDictt*)B)->count) {
6180  As = sToString(A);
6181  Bs = sToString(B);
6182  // TODO compare recursively
6183  r = strcmp(As,Bs);;
6184  freeManyS(As,Bs);
6185  return(r);
6186  }
6187  else {
6188  return(1);
6189  }
6190  case DOUBLE:
6191  if (((sDoublet*)A)->value < ((sDoublet*)B)->value) {
6192  return(-1);
6193  }
6194  else if (((sDoublet*)A)->value == ((sDoublet*)B)->value) {
6195  return(0);
6196  }
6197  else {
6198  return(1);
6199  }
6200  case INT:
6201  if (((sIntt*)A)->value < ((sIntt*)B)->value) {
6202  return(-1);
6203  }
6204  else if (((sIntt*)A)->value == ((sIntt*)B)->value) {
6205  return(0);
6206  }
6207  else {
6208  return(1);
6209  }
6210  case STRING:
6211  return(strcmp(sStringGetTiny((sStringt*)A), sStringGetTiny((sStringt*)B)));
6212  case ARRAY:
6213  if (((sArrayt*)A)->count < ((sArrayt*)B)->count) {
6214  return(-1);
6215  }
6216  else if (((sArrayt*)A)->count == ((sArrayt*)B)->count) {
6217  As = sToString(A);
6218  Bs = sToString(B);
6219  // TODO compare recursively
6220  r = strcmp(As,Bs);;
6221  freeManyS(As,Bs);
6222  return(r);
6223  }
6224  else {
6225  return(1);
6226  }
6227  case BYTES:
6228  if (((sBytest*)A)->count < ((sBytest*)B)->count) {
6229  return(-1);
6230  }
6231  else if (((sBytest*)A)->count == ((sBytest*)B)->count) {
6232  return(memcmp(&((sBytest*)A)->data, &((sBytest*)B)->data, ((sBytest*)A)->count));
6233  }
6234  else {
6235  return(1);
6236  }
6237  default:
6238  return(0);
6239  }
6240 }
6241  }
6242 
6243 internal smallArrayt* sortSmallArray(smallArrayt *self) {
6244  size_t len;
6245 
6246  len = lenSmallArray(self);
6247  // sanity checks
6248  if (!len) {
6249  return(NULL);
6250  }
6251  // sort
6252  smallt **arr = &(self->a->data);
6253  qsort(arr, lenSmallArray(self), sizeof(smallt *), sortSCmp);
6254  return(self);
6255 }
6256 
6257 #if (__APPLE__ || __FreeBSD__ || __DragonFly__)
6258 internal int sortFCmp(void *func, const void *a, const void *b) {
6259  shCmpt cmp;
6260 
6261  smallt *A = (*((smallt *const*)a));
6262  smallt *B = (*((smallt *const*)b));
6263 
6264  baset *aO = toBaset(A);;
6265  baset *bO = toBaset(B);;
6266 
6267  cmp = (shCmpt) func;
6268  int r = cmp(aO, bO);
6269 
6270  if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) {
6271  finishO(aO);
6272  }
6273  if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) {
6274  finishO(bO);
6275  }
6276  return(r);
6277 }
6278 #else
6279 internal int sortFCmp(const void *a, const void *b, void *func) {
6280  shCmpt cmp;
6281 
6282  smallt *A = (*((smallt *const*)a));
6283  smallt *B = (*((smallt *const*)b));
6284 
6285  baset *aO = toBaset(A);;
6286  baset *bO = toBaset(B);;
6287 
6288  cmp = (shCmpt) func;
6289  int r = cmp(aO, bO);
6290 
6291  if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) {
6292  finishO(aO);
6293  }
6294  if ((A->type != CONTAINER) || (A->type == CONTAINER && ((sContainert*)A)->dataType != SH_DT_BASET)) {
6295  finishO(bO);
6296  }
6297  return(r);
6298 }
6299 #endif
6300 
6301 internal int icSortSCmp(const void * a, const void * b) {
6302 
6303  // sanity checks
6304  smallt *A = (*((smallt *const*)a));
6305  smallt *B = (*((smallt *const*)b));
6306  if (!A && !B) {
6307  return(0);
6308  }
6309  if (!A && B) {
6310  return(-1);
6311  }
6312  if (A && !B) {
6313  return(1);
6314  }
6315  char *As, *Bs;
6316  int r;
6317  if (A->type != B->type) {
6318  return(A->type - B->type);
6319  }
6320  else {
6321  switch (A->type){
6322  case UNDEFINED:
6323  return(0);
6324  case BOOL:
6325  return((((sBoolt*)A)->value < ((sBoolt*)B)->value) * -1);
6326  case CONTAINER:
6327  return(0);
6328  case DICT:
6329  if (((sDictt*)A)->count < ((sDictt*)B)->count) {
6330  return(-1);
6331  }
6332  else if (((sDictt*)A)->count == ((sDictt*)B)->count) {
6333  As = sToString(A);
6334  Bs = sToString(B);
6335  // TODO compare recursively
6336  r = strcasecmp(As,Bs);;
6337  freeManyS(As,Bs);
6338  return(r);
6339  }
6340  else {
6341  return(1);
6342  }
6343  case DOUBLE:
6344  if (((sDoublet*)A)->value < ((sDoublet*)B)->value) {
6345  return(-1);
6346  }
6347  else if (((sDoublet*)A)->value == ((sDoublet*)B)->value) {
6348  return(0);
6349  }
6350  else {
6351  return(1);
6352  }
6353  case INT:
6354  if (((sIntt*)A)->value < ((sIntt*)B)->value) {
6355  return(-1);
6356  }
6357  else if (((sIntt*)A)->value == ((sIntt*)B)->value) {
6358  return(0);
6359  }
6360  else {
6361  return(1);
6362  }
6363  case STRING:
6364  return(strcasecmp(sStringGetTiny((sStringt*)A), sStringGetTiny((sStringt*)B)));
6365  case ARRAY:
6366  if (((sArrayt*)A)->count < ((sArrayt*)B)->count) {
6367  return(-1);
6368  }
6369  else if (((sArrayt*)A)->count == ((sArrayt*)B)->count) {
6370  As = sToString(A);
6371  Bs = sToString(B);
6372  // TODO compare recursively
6373  r = strcasecmp(As,Bs);;
6374  freeManyS(As,Bs);
6375  return(r);
6376  }
6377  else {
6378  return(1);
6379  }
6380  case BYTES:
6381  if (((sBytest*)A)->count < ((sBytest*)B)->count) {
6382  return(-1);
6383  }
6384  else if (((sBytest*)A)->count == ((sBytest*)B)->count) {
6385  return(memcmp(&((sBytest*)A)->data, &((sBytest*)B)->data, ((sBytest*)A)->count));
6386  }
6387  else {
6388  return(1);
6389  }
6390  default:
6391  return(0);
6392  }
6393 }
6394  }
6395 
6396 internal smallArrayt* icSortSmallArray(smallArrayt *self) {
6397  size_t len;
6398 
6399  len = lenSmallArray(self);
6400  // sanity checks
6401  if (!len) {
6402  return(NULL);
6403  }
6404  // sort
6405  smallt **arr = &(self->a->data);
6406  qsort(arr, lenSmallArray(self), sizeof(smallt *), icSortSCmp);
6407  return(self);
6408 }
6409 
6410 #if (__APPLE__ || __FreeBSD__ || __DragonFly__)
6411 // qsort_r has the parameters in a different order
6412 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction) {
6413  size_t len;
6414 
6415  len = lenSmallArray(self);
6416  // sanity checks
6417  if (!len || !compareFunction) {
6418  return(NULL);
6419  }
6420  // sort
6421  smallt **arr = &(self->a->data);
6422  qsort_r(arr, lenSmallArray(self), sizeof(smallt *), compareFunction, sortFCmp);
6423  return(self);
6424 }
6425 #else
6426 internal smallArrayt* sortFSmallArray(smallArrayt *self, shCmpt compareFunction) {
6427  size_t len;
6428 
6429  len = lenSmallArray(self);
6430  // sanity checks
6431  if (!len || !compareFunction) {
6432  return(NULL);
6433  }
6434  // sort
6435  smallt **arr = &(self->a->data);
6436  #if (__TERMUX__ || __OpenBSD__ || MUSL_LIBC || __sun__ || __HAIKU__)
6437  // qsort_r is missing in Termux
6438  smallt *tmp;
6439  QSORT(lenSmallArray(self), LESSsa, SWAPsa);
6440  #else
6441  qsort_r(arr, lenSmallArray(self), sizeof(smallt *), sortFCmp, compareFunction);
6442  #endif
6443  return(self);
6444 }
6445 #endif
6446 
6447 internal bool equalSmallArray(smallArrayt *self, smallArrayt *array) {
6448 
6449  // sanity checks
6450  if (!array) {
6451  return(false);
6452  }
6453 
6454  if (checkObjectTypes && array && !isOSmallArray(array)) {
6455  return(false);
6456  }
6457 
6458  if (!lenSmallArray(self) && !lenO(array)) {
6459  // both arrays are empty
6460  return(true);
6461  }
6462  if (!lenSmallArray(self) || !lenO(array)) {
6463  return(false);
6464  }
6465  if (lenSmallArray(self) != lenO(array)) {
6466  return(false);
6467  }
6468 
6469  // compare elements
6470  char *es = NULL;
6471  char *as = NULL;
6472  enumerateSArray(self->a, e, i) {
6473  if (not e) {
6474  if (not sArrayGetTiny(array->a, (uint32_t)i)) {
6475  continue;
6476  }
6477  else {
6478  return(false);
6479  }
6480  }
6481  if ((e->type != sArrayGetTiny(array->a, (uint32_t)i)->type)) {
6482  return(false);
6483  }
6484  else {
6485  switch (e->type) {
6486  // not needed always equal - case UNDEFINED:
6487  case BOOL:
6488  if (((sBoolt*)e)->value != ((sBoolt*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6489  return(false);
6490  }
6491  break;
6492  // TODO case CONTAINER:
6493  case DICT:
6494  es = sToString(e);
6495  as = sToString(sArrayGetTiny(array->a, (uint32_t)i));
6496  if (!strEq(es, as)) {
6497  free(es);
6498  free(as);
6499  return(false);
6500  }
6501  free(es);
6502  free(as);
6503  break;
6504  case DOUBLE:
6505  if (((sDoublet*)e)->value != ((sDoublet*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6506  return(false);
6507  }
6508  break;
6509  case INT:
6510  if (((sIntt*)e)->value != ((sIntt*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6511  return(false);
6512  }
6513  break;
6514  case STRING:
6515  if (!strEq(sStringGetTiny((sStringt*)e), sStringGetTiny((sStringt*)sArrayGetTiny(array->a, (uint32_t)i)))) {
6516  return(false);
6517  }
6518  break;
6519  case ARRAY:
6520  es = sToString(e);
6521  as = sToString(sArrayGetTiny(array->a, (uint32_t)i));
6522  if (!strEq(es, as)) {
6523  free(es);
6524  free(as);
6525  return(false);
6526  }
6527  free(es);
6528  free(as);
6529  break;
6530  case BYTES:
6531  if (((sBytest*)e)->count != ((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->count) {
6532  return(false);
6533  }
6534  if (memcmp(&((sBytest*)e)->data, &((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->data, ((sBytest*)e)->count)) {
6535  return(false);
6536  }
6537  break;
6538  default:
6539  // unsupported type
6540  return(false);
6541  break;
6542  }
6543  }
6544  }
6545 
6546  return(true);
6547 }
6548 
6549 internal bool equalSmallArraySmallJson(smallArrayt *self, smallJsont *array) {
6550 
6551  if (!array) {
6552  return(false);
6553  }
6554 
6555  // sanity checks
6556  if (checkObjectTypes && array && !isOSmallJson(array)) {
6557  return(false);
6558  }
6559 
6560  return(array->f->equalSmallArray(array, self));
6561 }
6562 
6563 internal bool equalSmallArrayArray(smallArrayt* self, char ** p2) {
6564 
6565  // sanity checks
6566  if (!lenSmallArray(self) && !listLengthS(p2)) {
6567  // both arrays are empty
6568  return(true);
6569  }
6570  if (!lenSmallArray(self) || !listLengthS(p2)) {
6571  return(false);
6572  }
6573  if (lenSmallArray(self) != listLengthS(p2)) {
6574  return(false);
6575  }
6576 
6577  // compare elements
6578  enumerateSArray(self->a, e, i) {
6579  if (not e) {
6580  return(false);
6581  }
6582  if (e->type != STRING) {
6583  return(false);
6584  }
6585  if (!strEq(sStringGetTiny((sStringt*)e), p2[i])) {
6586  return(false);
6587  }
6588  }
6589 
6590  return(true);
6591 }
6592 
6593 internal bool equalSmallArrayCArray(smallArrayt* self, const char ** p2) {
6594 
6595  // sanity checks
6596  if (!lenSmallArray(self) && !listLengthCS(p2)) {
6597  // both arrays are empty
6598  return(true);
6599  }
6600  if (!lenSmallArray(self) || !listLengthCS(p2)) {
6601  return(false);
6602  }
6603  if (lenSmallArray(self) != listLengthCS(p2)) {
6604  return(false);
6605  }
6606 
6607  // compare elements
6608  enumerateSArray(self->a, e, i) {
6609  if (not e) {
6610  return(false);
6611  }
6612  if (e->type != STRING) {
6613  return(false);
6614  }
6615  if (!strEq(sStringGetTiny((sStringt*)e), p2[i])) {
6616  return(false);
6617  }
6618  }
6619 
6620  return(true);
6621 }
6622 
6623 internal bool equalSmallArrayBase(smallArrayt* self, baset* p2) {
6624 
6625  if (!lenSmallArray(self) || !p2) {
6626  return(false);
6627  }
6628 
6629  if (!isOType(p2, "smallArray")) {
6630  return(false);
6631  }
6632 
6633  cast(smallArrayt *, arr, p2);
6634 
6635  return(equalSmallArray(self, arr));
6636 }
6637 
6638 
6639 internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array) {
6640 
6641  // sanity checks
6642  if (!array) {
6643  return(false);
6644  }
6645 
6646  if (checkObjectTypes && array && !isOSmallArray(array)) {
6647  return(false);
6648  }
6649 
6650  if (!lenSmallArray(self) && !lenO(array)) {
6651  // both arrays are empty
6652  return(true);
6653  }
6654  if (!lenSmallArray(self) || !lenO(array)) {
6655  return(false);
6656  }
6657  if (lenSmallArray(self) != lenO(array)) {
6658  return(false);
6659  }
6660 
6661  // compare elements
6662  char *es = NULL;
6663  char *as = NULL;
6664  enumerateSArray(self->a, e, i) {
6665  if (not e) {
6666  if (not sArrayGetTiny(array->a, (uint32_t)i)) {
6667  continue;
6668  }
6669  else {
6670  return(false);
6671  }
6672  }
6673  if ((e->type != sArrayGetTiny(array->a, (uint32_t)i)->type)) {
6674  return(false);
6675  }
6676  else {
6677  switch (e->type) {
6678  // not needed always equal - case UNDEFINED:
6679  case BOOL:
6680  if (((sBoolt*)e)->value != ((sBoolt*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6681  return(false);
6682  }
6683  break;
6684  // TODO case CONTAINER:
6685  case DICT:
6686  es = sToString(e);
6687  as = sToString(sArrayGetTiny(array->a, (uint32_t)i));
6688  if (!icEqS(es, as)) {
6689  free(es);
6690  free(as);
6691  return(false);
6692  }
6693  free(es);
6694  free(as);
6695  break;
6696  case DOUBLE:
6697  if (((sDoublet*)e)->value != ((sDoublet*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6698  return(false);
6699  }
6700  break;
6701  case INT:
6702  if (((sIntt*)e)->value != ((sIntt*)sArrayGetTiny(array->a, (uint32_t)i))->value) {
6703  return(false);
6704  }
6705  break;
6706  case STRING:
6707  if (!icEqS(sStringGetTiny((sStringt*)e), sStringGetTiny((sStringt*)sArrayGetTiny(array->a, (uint32_t)i)))) {
6708  return(false);
6709  }
6710  break;
6711  case ARRAY:
6712  es = sToString(e);
6713  as = sToString(sArrayGetTiny(array->a, (uint32_t)i));
6714  if (!icEqS(es, as)) {
6715  free(es);
6716  free(as);
6717  return(false);
6718  }
6719  free(es);
6720  free(as);
6721  break;
6722  case BYTES:
6723  if (((sBytest*)e)->count != ((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->count) {
6724  return(false);
6725  }
6726  if (memcmp(&((sBytest*)e)->data, &((sBytest*)sArrayGetTiny(array->a, (uint32_t)i))->data, ((sBytest*)e)->count)) {
6727  return(false);
6728  }
6729  break;
6730  default:
6731  // unsupported type
6732  return(false);
6733  break;
6734  }
6735  }
6736  }
6737 
6738  return(true);
6739 }
6740 
6741 internal bool icEqualSmallArraySmallJson(smallArrayt *self, smallJsont *array) {
6742 
6743  // sanity checks
6744  if (!array) {
6745  return(false);
6746  }
6747 
6748  if (checkObjectTypes && !isOSmallJson(array)) {
6749  return(false);
6750  }
6751 
6752  const char *type = getTopTypeO(array);
6753 
6754  if (!eqS(type,"array")) {
6755  return(false);
6756  }
6757 
6758  return(array->f->icEqualSmallArray(array, self));
6759 }
6760 
6761 bool icEqualSmallArrayArray(smallArrayt* self, char ** p2) {
6762 
6763  // sanity checks
6764  if (!lenSmallArray(self) && !listLengthS(p2)) {
6765  // both arrays are empty
6766  return(true);
6767  }
6768  if (!lenSmallArray(self) || !listLengthS(p2)) {
6769  return(false);
6770  }
6771  if (lenSmallArray(self) != listLengthS(p2)) {
6772  return(false);
6773  }
6774 
6775  // compare elements
6776  enumerateSArray(self->a, e, i) {
6777  if (not e) {
6778  return(false);
6779  }
6780  if (e->type != STRING) {
6781  return(false);
6782  }
6783  if (!icEqS(sStringGetTiny((sStringt*)e), p2[i])) {
6784  return(false);
6785  }
6786  }
6787 
6788  return(true);
6789 }
6790 
6791 bool icEqualSmallArrayCArray(smallArrayt* self, const char ** p2) {
6792 
6793  // sanity checks
6794  if (!lenSmallArray(self) && !listLengthCS(p2)) {
6795  // both arrays are empty
6796  return(true);
6797  }
6798  if (!lenSmallArray(self) || !listLengthCS(p2)) {
6799  return(false);
6800  }
6801  if (lenSmallArray(self) != listLengthCS(p2)) {
6802  return(false);
6803  }
6804 
6805  // compare elements
6806  enumerateSArray(self->a, e, i) {
6807  if (not e) {
6808  return(false);
6809  }
6810  if (e->type != STRING) {
6811  return(false);
6812  }
6813  if (!icEqS(sStringGetTiny((sStringt*)e), p2[i])) {
6814  return(false);
6815  }
6816  }
6817 
6818  return(true);
6819 }
6820 
6821 bool icEqualSmallArrayBase(smallArrayt* self, baset* p2) {
6822 
6823  if (!lenSmallArray(self) || !p2) {
6824  return(false);
6825  }
6826 
6827  if (!isOType(p2, "smallArray")) {
6828  return(false);
6829  }
6830 
6831  cast(smallArrayt *, arr, p2);
6832 
6833  return(icEqualSmallArray(self, arr));
6834 }
6835 
6836 
6837 internal size_t lenSmallArray(smallArrayt *self) {
6838 
6839  if (!self->a) {
6840  return(0);
6841  }
6842 
6843  return(self->a->count);
6844 }
6845 
6846 internal smallArrayt* trimSmallArray(smallArrayt *self) {
6847  smallt *o = NULL;
6848  sArrayt *a = NULL;
6849 
6850  a = allocSArray();
6851  if (!a) {
6852  return(NULL);
6853  }
6854 
6855  for (size_t i = 0 ; i < lenSmallArray(self); i++) {
6856  o = sArrayGetTiny(self->a, (uint32_t)i);
6857  if (o) {
6858  sArrayPushTiny(&a, o);
6859  }
6860  }
6861 
6862  free(self->a);
6863  self->a = a;
6864  return(self);
6865 }
6866 
6867 baset* getAtSmallArray(smallArrayt *self, int64_t index) {
6868 
6869  if (index >= (int64_t)lenSmallArray(self)) {
6870  return(NULL);
6871  }
6872  if (index < -(int64_t)lenSmallArray(self)) {
6873  return(NULL);
6874  }
6875  if (index < 0) {
6876  index = (int64_t)lenSmallArray(self) + index;
6877  }
6878 
6879  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
6880  if (!o) {
6881  return(NULL);
6882  }
6883 
6884  baset *r = toBaset(o);
6885  return(r);
6886 }
6887 
6888 internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index) {
6889 
6890  if (index >= (int64_t)lenSmallArray(self)) {
6891  return(NULL);
6892  }
6893  if (index < -(int64_t)lenSmallArray(self)) {
6894  return(NULL);
6895  }
6896  if (index < 0) {
6897  index = (int64_t)lenSmallArray(self) + index;
6898  }
6899 
6900  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
6901  if (!o) {
6902  return(NULL);
6903  }
6904  if (o->type != UNDEFINED) {
6905  return(NULL);
6906  }
6907  return(allocUndefined());
6908 }
6909 
6910 internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index) {
6911  smallBoolt *e = NULL;
6912  bool r = false;;
6913 
6914  e = getAtSmallBoolSmallArray(self, index);
6915  if (e) {
6916  r = e->f->get(e);
6917  finishO(e);
6918  }
6919  return(r);
6920 }
6921 
6922 internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index) {
6923  smallBoolt *e = NULL;
6924  bool* r = NULL;
6925 
6926  e = getAtSmallBoolSmallArray(self, index);
6927  if (e) {
6928  r = e->f->getP(e);
6929  finishO(e);
6930  }
6931  return(r);
6932 }
6933 
6934 internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index) {
6935  smallDoublet *e = NULL;
6936  double r = 0;;
6937 
6938  e = getAtSmallDoubleSmallArray(self, index);
6939  if (e) {
6940  r = e->f->get(e);
6941  finishO(e);
6942  }
6943  return(r);
6944 }
6945 
6946 internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index) {
6947  smallDoublet *e = NULL;
6948  double* r = NULL;
6949 
6950  e = getAtSmallDoubleSmallArray(self, index);
6951  if (e) {
6952  r = e->f->getP(e);
6953  finishO(e);
6954  }
6955  return(r);
6956 }
6957 
6958 internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index) {
6959  smallIntt *e = NULL;
6960  int64_t r = 0;;
6961 
6962  e = getAtSmallIntSmallArray(self, index);
6963  if (e) {
6964  r = e->f->get(e);
6965  finishO(e);
6966  }
6967  return(r);
6968 }
6969 
6970 internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index) {
6971  smallIntt *e = NULL;
6972  int64_t* r = NULL;
6973 
6974  e = getAtSmallIntSmallArray(self, index);
6975  if (e) {
6976  r = e->f->getP(e);
6977  finishO(e);
6978  }
6979  return(r);
6980 }
6981 
6982 internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index) {
6983  smallIntt *e = NULL;
6984  int32_t r = 0;;
6985 
6986  e = getAtSmallIntSmallArray(self, index);
6987  if (e) {
6988  r = (int32_t)e->f->get(e);
6989  finishO(e);
6990  }
6991  return(r);
6992 }
6993 
6994 internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index) {
6995  smallIntt *e = NULL;
6996  int32_t* r = NULL;
6997 
6998  e = getAtSmallIntSmallArray(self, index);
6999  if (e) {
7000  r = (int32_t *)e->f->getP(e);
7001  finishO(e);
7002  }
7003  return(r);
7004 }
7005 
7006 internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index) {
7007  smallIntt *e = NULL;
7008  uint64_t r = 0;;
7009 
7010  e = getAtSmallIntSmallArray(self, index);
7011  if (e) {
7012  r = (uint64_t)e->f->get(e);
7013  finishO(e);
7014  }
7015  return(r);
7016 }
7017 
7018 internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index) {
7019  smallIntt *e = NULL;
7020  uint64_t* r = NULL;
7021 
7022  e = getAtSmallIntSmallArray(self, index);
7023  if (e) {
7024  r = (uint64_t *)e->f->getP(e);
7025  finishO(e);
7026  }
7027  return(r);
7028 }
7029 
7030 internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index) {
7031  smallIntt *e = NULL;
7032  uint32_t r = 0;;
7033 
7034  e = getAtSmallIntSmallArray(self, index);
7035  if (e) {
7036  r = (uint32_t)e->f->get(e);
7037  finishO(e);
7038  }
7039  return(r);
7040 }
7041 
7042 internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index) {
7043  smallIntt *e = NULL;
7044  uint32_t* r = NULL;
7045 
7046  e = getAtSmallIntSmallArray(self, index);
7047  if (e) {
7048  r = (uint32_t *)e->f->getP(e);
7049  finishO(e);
7050  }
7051  return(r);
7052 }
7053 
7054 internal char* getAtSSmallArray(smallArrayt *self, int64_t index) {
7055  smallStringt *e = NULL;
7056  char* r = NULL;
7057 
7058  e = getAtSmallStringSmallArray(self, index);
7059  if (e) {
7060  r = e->f->get(e);
7061  finishO(e);
7062  }
7063  return(r);
7064 }
7065 
7066 internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index) {
7067 
7068  if (index >= (int64_t)lenSmallArray(self)) {
7069  return(NULL);
7070  }
7071  if (index < -(int64_t)lenSmallArray(self)) {
7072  return(NULL);
7073  }
7074  if (index < 0) {
7075  index = (int64_t)lenSmallArray(self) + index;
7076  }
7077 
7078  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7079  if (!o) {
7080  return(NULL);
7081  }
7082  if (o->type != DICT) {
7083  return(NULL);
7084  }
7085  return((smallDictt*) toBaset(o));
7086 }
7087 
7088 internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index) {
7089 
7090  if (index >= (int64_t)lenSmallArray(self)) {
7091  return(NULL);
7092  }
7093  if (index < -(int64_t)lenSmallArray(self)) {
7094  return(NULL);
7095  }
7096  if (index < 0) {
7097  index = (int64_t)lenSmallArray(self) + index;
7098  }
7099 
7100  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7101  if (!o) {
7102  return(NULL);
7103  }
7104  if (o->type != ARRAY) {
7105  return(NULL);
7106  }
7107  return((smallArrayt*) toBaset(o));
7108 }
7109 
7110 internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index) {
7111 
7112  if (index >= (int64_t)lenSmallArray(self)) {
7113  return(NULL);
7114  }
7115  if (index < -(int64_t)lenSmallArray(self)) {
7116  return(NULL);
7117  }
7118  if (index < 0) {
7119  index = (int64_t)lenSmallArray(self) + index;
7120  }
7121 
7122  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7123  if (!o) {
7124  return(NULL);
7125  }
7126  if (o->type != BOOL) {
7127  return(NULL);
7128  }
7129  return((smallBoolt*) toBaset(o));
7130 }
7131 
7132 internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index) {
7133 
7134  if (index >= (int64_t)lenSmallArray(self)) {
7135  return(NULL);
7136  }
7137  if (index < -(int64_t)lenSmallArray(self)) {
7138  return(NULL);
7139  }
7140  if (index < 0) {
7141  index = (int64_t)lenSmallArray(self) + index;
7142  }
7143 
7144  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7145  if (!o) {
7146  return(NULL);
7147  }
7148  if (o->type != BYTES) {
7149  return(NULL);
7150  }
7151  return((smallBytest*) toBaset(o));
7152 }
7153 
7154 internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
7155 
7156  if (index >= (int64_t)lenSmallArray(self)) {
7157  return(NULL);
7158  }
7159  if (index < -(int64_t)lenSmallArray(self)) {
7160  return(NULL);
7161  }
7162  if (index < 0) {
7163  index = (int64_t)lenSmallArray(self) + index;
7164  }
7165 
7166  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7167  if (!o) {
7168  return(NULL);
7169  }
7170  if (o->type != DOUBLE) {
7171  return(NULL);
7172  }
7173  return((smallDoublet*) toBaset(o));
7174 }
7175 
7176 internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index) {
7177 
7178  if (index >= (int64_t)lenSmallArray(self)) {
7179  return(NULL);
7180  }
7181  if (index < -(int64_t)lenSmallArray(self)) {
7182  return(NULL);
7183  }
7184  if (index < 0) {
7185  index = (int64_t)lenSmallArray(self) + index;
7186  }
7187 
7188  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7189  if (!o) {
7190  return(NULL);
7191  }
7192  if (o->type != INT) {
7193  return(NULL);
7194  }
7195  return((smallIntt*) toBaset(o));
7196 }
7197 
7198 internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index) {
7199 
7200  if (index >= (int64_t)lenSmallArray(self)) {
7201  return(NULL);
7202  }
7203  if (index < -(int64_t)lenSmallArray(self)) {
7204  return(NULL);
7205  }
7206  if (index < 0) {
7207  index = (int64_t)lenSmallArray(self) + index;
7208  }
7209 
7210  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7211  if (!o) {
7212  return(NULL);
7213  }
7214  if ((o->type == BYTES) || (o->type == CONTAINER)) {
7215  return(NULL);
7216  }
7217  baset *e = toBaset(o);
7218 
7219  createAllocateSmallJson(r);
7220  if (!r) {
7221  finishO(e);
7222  return(NULL);
7223  }
7224  setTopNFreeO(r, e);
7225  return(r);
7226 }
7227 
7228 internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index) {
7229 
7230  if (index >= (int64_t)lenSmallArray(self)) {
7231  return(NULL);
7232  }
7233  if (index < -(int64_t)lenSmallArray(self)) {
7234  return(NULL);
7235  }
7236  if (index < 0) {
7237  index = (int64_t)lenSmallArray(self) + index;
7238  }
7239 
7240  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7241  if (!o) {
7242  return(NULL);
7243  }
7244  if (o->type != STRING) {
7245  return(NULL);
7246  }
7247  return((smallStringt*) toBaset(o));
7248 }
7249 
7250 internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index) {
7251  smallContainert *e = NULL;
7252  void* r = NULL;
7253 
7254  e = getAtSmallContainerSmallArray(self, index);
7255  if (e) {
7256  r = e->f->get(e);
7257  finishO(e);
7258  }
7259  return(r);
7260 }
7261 
7262 internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index) {
7263 
7264  if (index >= (int64_t)lenSmallArray(self)) {
7265  return(NULL);
7266  }
7267  if (index < -(int64_t)lenSmallArray(self)) {
7268  return(NULL);
7269  }
7270  if (index < 0) {
7271  index = (int64_t)lenSmallArray(self) + index;
7272  }
7273 
7274  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7275  if (!o) {
7276  return(NULL);
7277  }
7278  if (o->type != CONTAINER) {
7279  return(NULL);
7280  }
7281  if (((sContainert*)o)->dataType == SH_DT_BASET) {
7282  return(NULL);
7283  }
7284  return((smallContainert*) toBaset(o));
7285 }
7286 
7287 baset* getAtNDupSmallArray(smallArrayt *self, int64_t index) {
7288 
7289  if (index >= (int64_t)lenSmallArray(self)) {
7290  return(NULL);
7291  }
7292  if (index < -(int64_t)lenSmallArray(self)) {
7293  return(NULL);
7294  }
7295  if (index < 0) {
7296  index = (int64_t)lenSmallArray(self) + index;
7297  }
7298 
7299  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7300  if (!o) {
7301  return(NULL);
7302  }
7303 
7304  if (o->type == UNDEFINED) {
7305  return((baset*) allocUndefined());
7306  }
7307 
7308  if (o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET)) {
7309  baset *b = ((sContainert*)o)->data;
7310  return(duplicateO(b));
7311  }
7312  return(toBaset(sDuplicate(o)));
7313 }
7314 
7315 internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index) {
7316 
7317  if (index >= (int64_t)lenSmallArray(self)) {
7318  return(NULL);
7319  }
7320  if (index < -(int64_t)lenSmallArray(self)) {
7321  return(NULL);
7322  }
7323  if (index < 0) {
7324  index = (int64_t)lenSmallArray(self) + index;
7325  }
7326 
7327  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7328  if (!o) {
7329  return(NULL);
7330  }
7331  if (o->type != UNDEFINED) {
7332  return(NULL);
7333  }
7334  return(allocUndefined());
7335 }
7336 
7337 internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index) {
7338  smallBoolt *e = NULL;
7339  bool r = false;;
7340 
7341  e = getAtNDupSmallBoolSmallArray(self, index);
7342  if (e) {
7343  r = e->f->get(e);
7344  terminateO(e);
7345  }
7346  return(r);
7347 }
7348 
7349 internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index) {
7350  smallDoublet *e = NULL;
7351  double r = 0;;
7352 
7353  e = getAtNDupSmallDoubleSmallArray(self, index);
7354  if (e) {
7355  r = e->f->get(e);
7356  terminateO(e);
7357  }
7358  return(r);
7359 }
7360 
7361 internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index) {
7362  smallIntt *e = NULL;
7363  int64_t r = 0;;
7364 
7365  e = getAtNDupSmallIntSmallArray(self, index);
7366  if (e) {
7367  r = e->f->get(e);
7368  terminateO(e);
7369  }
7370  return(r);
7371 }
7372 
7373 internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index) {
7374  smallIntt *e = NULL;
7375  int32_t r = 0;;
7376 
7377  e = getAtNDupSmallIntSmallArray(self, index);
7378  if (e) {
7379  r = (int32_t)e->f->get(e);
7380  terminateO(e);
7381  }
7382  return(r);
7383 }
7384 
7385 internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index) {
7386  smallIntt *e = NULL;
7387  uint64_t r = 0;;
7388 
7389  e = getAtNDupSmallIntSmallArray(self, index);
7390  if (e) {
7391  r = (uint64_t)e->f->get(e);
7392  terminateO(e);
7393  }
7394  return(r);
7395 }
7396 
7397 internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index) {
7398  smallIntt *e = NULL;
7399  uint32_t r = 0;;
7400 
7401  e = getAtNDupSmallIntSmallArray(self, index);
7402  if (e) {
7403  r = (uint32_t)e->f->get(e);
7404  terminateO(e);
7405  }
7406  return(r);
7407 }
7408 
7409 internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index) {
7410  smallStringt *e = NULL;
7411  char* r = NULL;
7412 
7413  e = getAtNDupSmallStringSmallArray(self, index);
7414  if (e) {
7415  r = e->f->toString(e);
7416  terminateO(e);
7417  }
7418  return(r);
7419 }
7420 
7421 internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index) {
7422 
7423  if (index >= (int64_t)lenSmallArray(self)) {
7424  return(NULL);
7425  }
7426  if (index < -(int64_t)lenSmallArray(self)) {
7427  return(NULL);
7428  }
7429  if (index < 0) {
7430  index = (int64_t)lenSmallArray(self) + index;
7431  }
7432 
7433  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7434  if (!o) {
7435  return(NULL);
7436  }
7437  if (o->type != DICT) {
7438  return(NULL);
7439  }
7440  return((smallDictt*)toBaset(sDuplicate(o)));
7441 }
7442 
7443 internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index) {
7444 
7445  if (index >= (int64_t)lenSmallArray(self)) {
7446  return(NULL);
7447  }
7448  if (index < -(int64_t)lenSmallArray(self)) {
7449  return(NULL);
7450  }
7451  if (index < 0) {
7452  index = (int64_t)lenSmallArray(self) + index;
7453  }
7454 
7455  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7456  if (!o) {
7457  return(NULL);
7458  }
7459  if (o->type != ARRAY) {
7460  return(NULL);
7461  }
7462  return((smallArrayt*)toBaset(sDuplicate(o)));
7463 }
7464 
7465 internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index) {
7466 
7467  if (index >= (int64_t)lenSmallArray(self)) {
7468  return(NULL);
7469  }
7470  if (index < -(int64_t)lenSmallArray(self)) {
7471  return(NULL);
7472  }
7473  if (index < 0) {
7474  index = (int64_t)lenSmallArray(self) + index;
7475  }
7476 
7477  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7478  if (!o) {
7479  return(NULL);
7480  }
7481  if (o->type != BOOL) {
7482  return(NULL);
7483  }
7484  return((smallBoolt*)toBaset(sDuplicate(o)));
7485 }
7486 
7487 internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index) {
7488 
7489  if (index >= (int64_t)lenSmallArray(self)) {
7490  return(NULL);
7491  }
7492  if (index < -(int64_t)lenSmallArray(self)) {
7493  return(NULL);
7494  }
7495  if (index < 0) {
7496  index = (int64_t)lenSmallArray(self) + index;
7497  }
7498 
7499  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7500  if (!o) {
7501  return(NULL);
7502  }
7503  if (o->type != BYTES) {
7504  return(NULL);
7505  }
7506  return((smallBytest*)toBaset(sDuplicate(o)));
7507 }
7508 
7509 internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
7510 
7511  if (index >= (int64_t)lenSmallArray(self)) {
7512  return(NULL);
7513  }
7514  if (index < -(int64_t)lenSmallArray(self)) {
7515  return(NULL);
7516  }
7517  if (index < 0) {
7518  index = (int64_t)lenSmallArray(self) + index;
7519  }
7520 
7521  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7522  if (!o) {
7523  return(NULL);
7524  }
7525  if (o->type != DOUBLE) {
7526  return(NULL);
7527  }
7528  return((smallDoublet*)toBaset(sDuplicate(o)));
7529 }
7530 
7531 internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index) {
7532 
7533  if (index >= (int64_t)lenSmallArray(self)) {
7534  return(NULL);
7535  }
7536  if (index < -(int64_t)lenSmallArray(self)) {
7537  return(NULL);
7538  }
7539  if (index < 0) {
7540  index = (int64_t)lenSmallArray(self) + index;
7541  }
7542 
7543  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7544  if (!o) {
7545  return(NULL);
7546  }
7547  if (o->type != INT) {
7548  return(NULL);
7549  }
7550  return((smallIntt*)toBaset(sDuplicate(o)));
7551 }
7552 
7553 internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index) {
7554 
7555  if (index >= (int64_t)lenSmallArray(self)) {
7556  return(NULL);
7557  }
7558  if (index < -(int64_t)lenSmallArray(self)) {
7559  return(NULL);
7560  }
7561  if (index < 0) {
7562  index = (int64_t)lenSmallArray(self) + index;
7563  }
7564 
7565  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7566  if (!o) {
7567  return(NULL);
7568  }
7569  if ((o->type == BYTES) || (o->type == CONTAINER)) {
7570  return(NULL);
7571  }
7572 
7573  baset *e = toBaset(sDuplicate(o));
7574 
7575  createAllocateSmallJson(r);
7576  if (!r) {
7577  finishO(e);
7578  return(NULL);
7579  }
7580  setTopNFreeO(r, e);
7581  return(r);
7582 }
7583 
7584 internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index) {
7585 
7586  if (index >= (int64_t)lenSmallArray(self)) {
7587  return(NULL);
7588  }
7589  if (index < -(int64_t)lenSmallArray(self)) {
7590  return(NULL);
7591  }
7592  if (index < 0) {
7593  index = (int64_t)lenSmallArray(self) + index;
7594  }
7595 
7596  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7597  if (!o) {
7598  return(NULL);
7599  }
7600  if (o->type != STRING) {
7601  return(NULL);
7602  }
7603  return((smallStringt*)toBaset(sDuplicate(o)));
7604 }
7605 
7606 internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index) {
7607  smallContainert *e = NULL;
7608  void* r = NULL;
7609 
7610  e = getAtNDupSmallContainerSmallArray(self, index);
7611  if (e) {
7612  r = e->f->get(e);
7613  smashO(e);
7614  }
7615  return(r);
7616 }
7617 
7618 internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index) {
7619 
7620  if (index >= (int64_t)lenSmallArray(self)) {
7621  return(NULL);
7622  }
7623  if (index < -(int64_t)lenSmallArray(self)) {
7624  return(NULL);
7625  }
7626  if (index < 0) {
7627  index = (int64_t)lenSmallArray(self) + index;
7628  }
7629 
7630  smallt *o = sArrayGetTiny(self->a, (uint32_t)index);
7631  if (!o) {
7632  return(NULL);
7633  }
7634  if (o->type != CONTAINER) {
7635  return(NULL);
7636  }
7637  if (((sContainert*)o)->dataType == SH_DT_BASET) {
7638  return(NULL);
7639  }
7640  smallContainert *e = (smallContainert*)toBaset(o);
7641  smallContainert *r = duplicateO(e);
7642  finishO(e);
7643  return(r);
7644 }
7645 
7646 internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value) {
7647 
7648  if (!value) {
7649  return(NULL);
7650  }
7651 
7652  if (index >= (int64_t)lenSmallArray(self)) {
7653  return(NULL);
7654  }
7655  if (index < -(int64_t)lenSmallArray(self)) {
7656  return(NULL);
7657  }
7658  if (index < 0) {
7659  index = (int64_t)lenSmallArray(self) + index;
7660  }
7661 
7662  sArraySetTiny(self->a, (uint32_t)index, toSmallt(value));
7663  return(self);
7664 }
7665 
7666 internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index) {
7667 
7668  if (index >= (int64_t)lenSmallArray(self)) {
7669  return(NULL);
7670  }
7671  if (index < -(int64_t)lenSmallArray(self)) {
7672  return(NULL);
7673  }
7674  if (index < 0) {
7675  index = (int64_t)lenSmallArray(self) + index;
7676  }
7677 
7678  smallt *o = (smallt *) allocSUndefined();
7679  if (!o) {
7680  return(NULL);
7681  }
7682  sArraySetTiny(self->a, (uint32_t)index, o);
7683  return(self);
7684 }
7685 
7686 internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value) {
7687 
7688  if (index >= (int64_t)lenSmallArray(self)) {
7689  return(NULL);
7690  }
7691  if (index < -(int64_t)lenSmallArray(self)) {
7692  return(NULL);
7693  }
7694  if (index < 0) {
7695  index = (int64_t)lenSmallArray(self) + index;
7696  }
7697 
7698  smallt *o = (smallt *) allocSBool(value);
7699  if (!o) {
7700  return(NULL);
7701  }
7702  sArraySetTiny(self->a, (uint32_t)index, o);
7703  return(self);
7704 }
7705 
7706 internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value) {
7707 
7708  if (index >= (int64_t)lenSmallArray(self)) {
7709  return(NULL);
7710  }
7711  if (index < -(int64_t)lenSmallArray(self)) {
7712  return(NULL);
7713  }
7714  if (index < 0) {
7715  index = (int64_t)lenSmallArray(self) + index;
7716  }
7717 
7718  smallt *o = (smallt *) allocSDouble(value);
7719  if (!o) {
7720  return(NULL);
7721  }
7722  sArraySetTiny(self->a, (uint32_t)index, o);
7723  return(self);
7724 }
7725 
7726 internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value) {
7727 
7728  if (index >= (int64_t)lenSmallArray(self)) {
7729  return(NULL);
7730  }
7731  if (index < -(int64_t)lenSmallArray(self)) {
7732  return(NULL);
7733  }
7734  if (index < 0) {
7735  index = (int64_t)lenSmallArray(self) + index;
7736  }
7737 
7738  smallt *o = (smallt *) allocSInt(value);
7739  if (!o) {
7740  return(NULL);
7741  }
7742  sArraySetTiny(self->a, (uint32_t)index, o);
7743  return(self);
7744 }
7745 
7746 internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string) {
7747 
7748  if (!string) {
7749  return(NULL);
7750  }
7751 
7752  if (index >= (int64_t)lenSmallArray(self)) {
7753  return(NULL);
7754  }
7755  if (index < -(int64_t)lenSmallArray(self)) {
7756  return(NULL);
7757  }
7758  if (index < 0) {
7759  index = (int64_t)lenSmallArray(self) + index;
7760  }
7761 
7762  smallt *o;
7763  isError(o, (smallt *) allocSStringTiny(string)) return(NULL);
7764  sArraySetTiny(self->a, (uint32_t)index, o);
7765  return(self);
7766 }
7767 
7768 internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c) {
7769 
7770  charToS(s, c);
7771  return(setAtSSmallArray(self, index, s));
7772 }
7773 
7774 internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
7775 
7776  if (!dict) {
7777  return(NULL);
7778  }
7779 
7780  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
7781  return(NULL);
7782  }
7783 
7784  if (index >= (int64_t)lenSmallArray(self)) {
7785  return(NULL);
7786  }
7787  if (index < -(int64_t)lenSmallArray(self)) {
7788  return(NULL);
7789  }
7790  if (index < 0) {
7791  index = (int64_t)lenSmallArray(self) + index;
7792  }
7793 
7794  if (!dict->d) {
7795  isError(dict->d, allocSDict()) return(NULL);
7796  }
7797 
7798  sArraySetTiny(self->a, (uint32_t)index, (smallt *)dict->d);
7799  return(self);
7800 }
7801 
7802 
7803 internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
7804 
7805  if (!array) {
7806  return(NULL);
7807  }
7808 
7809  if (checkObjectTypes && array && !isOSmallArray(array)) {
7810  return(NULL);
7811  }
7812 
7813  if (index >= (int64_t)lenSmallArray(self)) {
7814  return(NULL);
7815  }
7816  if (index < -(int64_t)lenSmallArray(self)) {
7817  return(NULL);
7818  }
7819  if (index < 0) {
7820  index = (int64_t)lenSmallArray(self) + index;
7821  }
7822 
7823  if (!array->a) {
7824  // allocate empty array
7825  isError(array->a, allocSArray()) return(NULL);
7826  }
7827 
7828  sArraySetTiny(self->a, (uint32_t)index, (smallt *)array->a);
7829  return(self);
7830 }
7831 
7832 internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array) {
7833 
7834  if (!array) {
7835  return(NULL);
7836  }
7837 
7838  if (index >= (int64_t)lenSmallArray(self)) {
7839  return(NULL);
7840  }
7841  if (index < -(int64_t)lenSmallArray(self)) {
7842  return(NULL);
7843  }
7844  if (index < 0) {
7845  index = (int64_t)lenSmallArray(self) + index;
7846  }
7847 
7848  sArrayt *a = allocSArray();
7849  if (!a) {
7850  return(NULL);
7851  }
7852 
7853  forEachCharP(array, e) {
7854  sStringt *s = allocSStringTiny(*e);
7855  if (!s) {
7856  if (a) {
7857  sArrayFreeTiny(a);
7858  }
7859  return(NULL);
7860  }
7861  sArrayPushTiny(&a, (smallt *) s);
7862  }
7863 
7864  sArraySetTiny(self->a, (uint32_t)index, (smallt *)a);
7865  return(self);
7866 }
7867 
7868 internal smallArrayt* setAtCArraycSmallArray(smallArrayt *self, int64_t index, const char **array) {
7869 
7870  if (!array) {
7871  return(NULL);
7872  }
7873 
7874  if (index >= (int64_t)lenSmallArray(self)) {
7875  return(NULL);
7876  }
7877  if (index < -(int64_t)lenSmallArray(self)) {
7878  return(NULL);
7879  }
7880  if (index < 0) {
7881  index = (int64_t)lenSmallArray(self) + index;
7882  }
7883 
7884  sArrayt *a = allocSArray();
7885  if (!a) {
7886  return(NULL);
7887  }
7888 
7889  forEachCCharP(array, e) {
7890  sStringt *s = allocSStringTiny(*e);
7891  if (!s) {
7892  if (a) {
7893  sArrayFreeTiny(a);
7894  }
7895  return(NULL);
7896  }
7897  sArrayPushTiny(&a, (smallt *) s);
7898  }
7899 
7900  sArraySetTiny(self->a, (uint32_t)index, (smallt *)a);
7901  return(self);
7902 }
7903 
7904 internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) {
7905 
7906  if (!value) {
7907  return(NULL);
7908  }
7909 
7910  if (checkObjectTypes && value && !isOSmallBool(value)) {
7911  return(NULL);
7912  }
7913 
7914  if (index >= (int64_t)lenSmallArray(self)) {
7915  return(NULL);
7916  }
7917  if (index < -(int64_t)lenSmallArray(self)) {
7918  return(NULL);
7919  }
7920  if (index < 0) {
7921  index = (int64_t)lenSmallArray(self) + index;
7922  }
7923 
7924  if (!value->value) {
7925  isError(value->value, allocSBool(false)) return(NULL);
7926  }
7927  sArraySetTiny(self->a, (uint32_t)index, (smallt *) value->value);
7928  return(self);
7929 }
7930 
7931 internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) {
7932 
7933  if (!value) {
7934  return(NULL);
7935  }
7936 
7937  if (checkObjectTypes && value && !isOSmallBytes(value)) {
7938  return(NULL);
7939  }
7940 
7941  if (index >= (int64_t)lenSmallArray(self)) {
7942  return(NULL);
7943  }
7944  if (index < -(int64_t)lenSmallArray(self)) {
7945  return(NULL);
7946  }
7947  if (index < 0) {
7948  index = (int64_t)lenSmallArray(self) + index;
7949  }
7950 
7951  if (!value->B) {
7952  isError(value->B, allocSBytes()) return(NULL);
7953  }
7954  sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->B);
7955  return(self);
7956 }
7957 
7958 internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) {
7959 
7960  if (!value) {
7961  return(NULL);
7962  }
7963 
7964  if (checkObjectTypes && value && !isOSmallDouble(value)) {
7965  return(NULL);
7966  }
7967 
7968  if (index >= (int64_t)lenSmallArray(self)) {
7969  return(NULL);
7970  }
7971  if (index < -(int64_t)lenSmallArray(self)) {
7972  return(NULL);
7973  }
7974  if (index < 0) {
7975  index = (int64_t)lenSmallArray(self) + index;
7976  }
7977 
7978  if (!value->value) {
7979  isError(value->value, allocSDouble(0)) return(NULL);
7980  }
7981  sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->value);
7982  return(self);
7983 }
7984 
7985 internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) {
7986 
7987  if (!value) {
7988  return(NULL);
7989  }
7990 
7991  if (checkObjectTypes && value && !isOSmallInt(value)) {
7992  return(NULL);
7993  }
7994 
7995  if (index >= (int64_t)lenSmallArray(self)) {
7996  return(NULL);
7997  }
7998  if (index < -(int64_t)lenSmallArray(self)) {
7999  return(NULL);
8000  }
8001  if (index < 0) {
8002  index = (int64_t)lenSmallArray(self) + index;
8003  }
8004 
8005  if (!value->value) {
8006  isError(value->value, allocSInt(0)) return(NULL);
8007  }
8008  sArraySetTiny(self->a, (uint32_t)index, (smallt*) value->value);
8009  return(self);
8010 }
8011 
8012 internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) {
8013 
8014  if (!value) {
8015  return(NULL);
8016  }
8017 
8018  if (checkObjectTypes && value && !isOSmallJson(value)) {
8019  return(NULL);
8020  }
8021 
8022  if (index >= (int64_t)lenSmallArray(self)) {
8023  return(NULL);
8024  }
8025  if (index < -(int64_t)lenSmallArray(self)) {
8026  return(NULL);
8027  }
8028  if (index < 0) {
8029  index = (int64_t)lenSmallArray(self) + index;
8030  }
8031 
8032  smallt *o = getsoO(value);
8033  if (!o) {
8034  // smallJson is empty, create an empty dict
8035  isError(o, (smallt*) allocSDict()) return(NULL);
8036  setsoO(value, o);
8037  }
8038 
8039  sArraySetTiny(self->a, (uint32_t)index, o);
8040  return(self);
8041 }
8042 
8043 internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
8044 
8045  if (!string) {
8046  return(NULL);
8047  }
8048 
8049  if (checkObjectTypes && string && !isOSmallString(string)) {
8050  return(NULL);
8051  }
8052 
8053  if (index >= (int64_t)lenSmallArray(self)) {
8054  return(NULL);
8055  }
8056  if (index < -(int64_t)lenSmallArray(self)) {
8057  return(NULL);
8058  }
8059  if (index < 0) {
8060  index = (int64_t)lenSmallArray(self) + index;
8061  }
8062 
8063  if (!string->data) {
8064  isError(string->data, allocSStringTiny("")) return(NULL);
8065  }
8066  sArraySetTiny(self->a, (uint32_t)index, (smallt *)string->data);
8067  return(self);
8068 }
8069 
8070 internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) {
8071 
8072  if (!container) {
8073  return(NULL);
8074  }
8075 
8076  if (checkObjectTypes && container && !isOSmallContainer(container)) {
8077  return(NULL);
8078  }
8079 
8080  if (index >= (int64_t)lenSmallArray(self)) {
8081  return(NULL);
8082  }
8083  if (index < -(int64_t)lenSmallArray(self)) {
8084  return(NULL);
8085  }
8086  if (index < 0) {
8087  index = (int64_t)lenSmallArray(self) + index;
8088  }
8089 
8090  if (!container->data) {
8091  isError(container->data, allocSContainer(NULL)) return(NULL);
8092  }
8093  sArraySetTiny(self->a, (uint32_t)index, (smallt *) container->data);
8094  return(self);
8095 }
8096 
8097 internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value) {
8098 
8099  if (!value) {
8100  return(NULL);
8101  }
8102 
8103  if (index >= (int64_t)lenSmallArray(self)) {
8104  return(NULL);
8105  }
8106  if (index < -(int64_t)lenSmallArray(self)) {
8107  return(NULL);
8108  }
8109  if (index < 0) {
8110  index = (int64_t)lenSmallArray(self) + index;
8111  }
8112 
8113  smallt *o = toSmallt(value);
8114  if (!o) {
8115  return(NULL);
8116  }
8117  sArraySetTiny(self->a, (uint32_t)index, o);
8118 
8119  if (!(o->type == CONTAINER && (((sContainert*)o)->dataType == SH_DT_BASET))) {
8120  finishO(value);
8121  }
8122  return(self);
8123 }
8124 
8125 internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u) {
8126 
8127  smallArrayt *r = setAtUndefinedSmallArray(self, index);
8128  if (r) {
8129  terminateO(u);
8130  }
8131  return(r);
8132 }
8133 
8134 internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string) {
8135 
8136  smallArrayt *r = setAtSSmallArray(self, index, string);
8137  if (r) {
8138  free(string);
8139  }
8140  return(r);
8141 }
8142 
8143 internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
8144 
8145  smallArrayt *r = setAtDictSmallArray(self, index, dict);
8146  if (r) {
8147  finishO(dict);
8148  }
8149  return(r);
8150 }
8151 
8152 internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
8153 
8154  smallArrayt *r = setAtArraySmallArray(self, index, array);
8155  if (r) {
8156  finishO(array);
8157  }
8158  return(r);
8159 }
8160 
8161 internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array) {
8162 
8163  smallArrayt *r = setAtArraycSmallArray(self, index, array);
8164  if (r) {
8165  listFreeS(array);
8166  }
8167  return(r);
8168 }
8169 
8170 internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) {
8171 
8172  smallArrayt *r = setAtSmallBoolSmallArray(self, index, value);
8173  if (r) {
8174  finishO(value);
8175  }
8176  return(r);
8177 }
8178 
8179 internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) {
8180 
8181  smallArrayt *r = setAtSmallBytesSmallArray(self, index, value);
8182  if (r) {
8183  finishO(value);
8184  }
8185  return(r);
8186 }
8187 
8188 internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) {
8189 
8190  smallArrayt *r = setAtSmallDoubleSmallArray(self, index, value);
8191  if (r) {
8192  finishO(value);
8193  }
8194  return(r);
8195 }
8196 
8197 internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) {
8198 
8199  smallArrayt *r = setAtSmallIntSmallArray(self, index, value);
8200  if (r) {
8201  finishO(value);
8202  }
8203  return(r);
8204 }
8205 
8206 internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) {
8207 
8208  smallArrayt *r = setAtSmallJsonSmallArray(self, index, value);
8209  if (r) {
8210  finishO(value);
8211  }
8212  return(r);
8213 }
8214 
8215 internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
8216 
8217  smallArrayt *r = setAtSmallStringSmallArray(self, index, string);
8218  if (r) {
8219  finishO(string);
8220  }
8221  return(r);
8222 }
8223 
8224 internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) {
8225 
8226  smallArrayt *r = setAtSmallContainerSmallArray(self, index, container);
8227  if (r) {
8228  finishO(container);
8229  }
8230  return(r);
8231 }
8232 
8233 
8234 internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
8235 
8236  if (!dict) {
8237  return(NULL);
8238  }
8239 
8240  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
8241  return(NULL);
8242  }
8243 
8244  if (index >= (int64_t)lenSmallArray(self)) {
8245  return(NULL);
8246  }
8247  if (index < -(int64_t)lenSmallArray(self)) {
8248  return(NULL);
8249  }
8250  if (index < 0) {
8251  index = (int64_t)lenSmallArray(self) + index;
8252  }
8253 
8254  if (!dict->d) {
8255  // realloc error
8256  return(NULL);
8257  }
8258 
8259  sArraySetP(self->a, (uint32_t)index, (smallt *)dict->d);
8260  return(self);
8261 }
8262 
8263 internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
8264 
8265  if (!array) {
8266  return(NULL);
8267  }
8268 
8269  if (checkObjectTypes && array && !isOSmallArray(array)) {
8270  return(NULL);
8271  }
8272 
8273  if (index >= (int64_t)lenSmallArray(self)) {
8274  return(NULL);
8275  }
8276  if (index < -(int64_t)lenSmallArray(self)) {
8277  return(NULL);
8278  }
8279  if (index < 0) {
8280  index = (int64_t)lenSmallArray(self) + index;
8281  }
8282 
8283  if (!array->a) {
8284  // realloc error
8285  return(NULL);
8286  }
8287 
8288  sArraySetP(self->a, (uint32_t)index, (smallt *)array->a);
8289  return(self);
8290 }
8291 
8292 internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) {
8293 
8294  if (!json) {
8295  return(NULL);
8296  }
8297 
8298  if (checkObjectTypes && json && !isOSmallJson(json)) {
8299  return(NULL);
8300  }
8301 
8302  if (index >= (int64_t)lenSmallArray(self)) {
8303  return(NULL);
8304  }
8305  if (index < -(int64_t)lenSmallArray(self)) {
8306  return(NULL);
8307  }
8308  if (index < 0) {
8309  index = (int64_t)lenSmallArray(self) + index;
8310  }
8311 
8312  smallt *o;
8313  o = getsoO(json);
8314  if (!o) {
8315  // realloc error
8316  return(NULL);
8317  }
8318  sArraySetP(self->a, (uint32_t)index, o);
8319  return(self);
8320 }
8321 
8322 internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
8323 
8324  if (!string) {
8325  return(NULL);
8326  }
8327 
8328  if (checkObjectTypes && string && !isOSmallString(string)) {
8329  return(NULL);
8330  }
8331 
8332  if (index >= (int64_t)lenSmallArray(self)) {
8333  return(NULL);
8334  }
8335  if (index < -(int64_t)lenSmallArray(self)) {
8336  return(NULL);
8337  }
8338  if (index < 0) {
8339  index = (int64_t)lenSmallArray(self) + index;
8340  }
8341 
8342  if (!string->data) {
8343  // realloc error
8344  return(NULL);
8345  }
8346 
8347  smallt *o = (smallt *) string->data;
8348  sArraySetP(self->a, (uint32_t)index, o);
8349  return(self);
8350 }
8351 
8352 internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
8353 
8354  if (!dict) {
8355  return(NULL);
8356  }
8357 
8358  if (checkObjectTypes && dict && !isOSmallDict(dict)) {
8359  return(NULL);
8360  }
8361 
8362  if (index >= (int64_t)lenSmallArray(self)) {
8363  return(NULL);
8364  }
8365  if (index < -(int64_t)lenSmallArray(self)) {
8366  return(NULL);
8367  }
8368  if (index < 0) {
8369  index = (int64_t)lenSmallArray(self) + index;
8370  }
8371 
8372  if (!dict->d) {
8373  // realloc error
8374  return(NULL);
8375  }
8376 
8377  sArraySetP(self->a, (uint32_t)index, (smallt *)dict->d);
8378  finishO(dict);
8379  return(self);
8380 }
8381 
8382 
8383 internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
8384 
8385  if (!array) {
8386  return(NULL);
8387  }
8388 
8389  if (checkObjectTypes && array && !isOSmallArray(array)) {
8390  return(NULL);
8391  }
8392 
8393  if (index >= (int64_t)lenSmallArray(self)) {
8394  return(NULL);
8395  }
8396  if (index < -(int64_t)lenSmallArray(self)) {
8397  return(NULL);
8398  }
8399  if (index < 0) {
8400  index = (int64_t)lenSmallArray(self) + index;
8401  }
8402 
8403  if (!array->a) {
8404  // realloc error
8405  return(NULL);
8406  }
8407 
8408  sArraySetP(self->a, (uint32_t)index, (smallt *)array->a);
8409  finishO(array);
8410  return(self);
8411 }
8412 
8413 internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) {
8414 
8415  if (!json) {
8416  return(NULL);
8417  }
8418 
8419  if (checkObjectTypes && json && !isOSmallJson(json)) {
8420  return(NULL);
8421  }
8422 
8423  if (index >= (int64_t)lenSmallArray(self)) {
8424  return(NULL);
8425  }
8426  if (index < -(int64_t)lenSmallArray(self)) {
8427  return(NULL);
8428  }
8429  if (index < 0) {
8430  index = (int64_t)lenSmallArray(self) + index;
8431  }
8432 
8433  smallt *o;
8434  o = getsoO(json);;
8435  if (!o) {
8436  // realloc error
8437  return(NULL);
8438  }
8439  finishO(json);
8440  sArraySetP(self->a, (uint32_t)index, o);
8441  return(self);
8442 }
8443 
8444 internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
8445 
8446  if (!string) {
8447  return(NULL);
8448  }
8449 
8450  if (checkObjectTypes && string && !isOSmallString(string)) {
8451  return(NULL);
8452  }
8453 
8454  if (index >= (int64_t)lenSmallArray(self)) {
8455  return(NULL);
8456  }
8457  if (index < -(int64_t)lenSmallArray(self)) {
8458  return(NULL);
8459  }
8460  if (index < 0) {
8461  index = (int64_t)lenSmallArray(self) + index;
8462  }
8463 
8464  if (!string->data) {
8465  // realloc error
8466  return(NULL);
8467  }
8468 
8469  smallt *o = (smallt *) string->data;
8470  finishO(string);
8471  sArraySetP(self->a, (uint32_t)index, o);
8472  return(self);
8473 }
8474 
8475 internal double getNumSmallArray(smallArrayt *self, int64_t index) {
8476 
8477  if (index >= (int64_t)lenSmallArray(self)) {
8478  return(0);
8479  }
8480  if (index < -(int64_t)lenSmallArray(self)) {
8481  return(0);
8482  }
8483  if (index < 0) {
8484  index = (int64_t)lenSmallArray(self) + index;
8485  }
8486 
8487  smallt *e = sArrayGetTiny(self->a, (uint32_t)index);
8488  if (!e) {
8489  return(0);
8490  }
8491  if (e->type != INT && e->type != DOUBLE) {
8492  return(0);
8493  }
8494 
8495  baset *o = toBaset(e);
8496 
8497  double r = 0;
8498  if (isOSmallDouble(o)) {
8499  r = getValO((smallDoublet*)o);
8500  }
8501  elif (isOSmallInt(o)) {
8502  r = (double)getValO((smallIntt*)o);
8503  }
8504  finishO(o);
8505  return(r);
8506 }
8507 
8508 internal bool hasSmallArray(smallArrayt *self, baset *value) {
8509 
8510  if (!value) {
8511  return(false);
8512  }
8513 
8514  if (indexOfSmallArray(self, value) == -1) {
8515  return(false);
8516  }
8517 
8518  return(true);
8519 }
8520 
8521 internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *u) {
8522 
8523  if (!u) {
8524  return(false);
8525  }
8526 
8527  if (checkObjectTypes && !isOUndefined(u)) {
8528  return(false);
8529  }
8530 
8531  if (indexOfUndefinedSmallArray(self, u) == -1) {
8532  return(false);
8533  }
8534 
8535  return(true);
8536 }
8537 
8538 internal bool hasBoolSmallArray(smallArrayt *self, bool value) {
8539 
8540  if (indexOfBoolSmallArray(self, value) == -1) {
8541  return(false);
8542  }
8543 
8544  return(true);
8545 }
8546 
8547 internal bool hasDoubleSmallArray(smallArrayt *self, double value) {
8548 
8549  if (indexOfDoubleSmallArray(self, value) == -1) {
8550  return(false);
8551  }
8552 
8553  return(true);
8554 }
8555 
8556 internal bool hasIntSmallArray(smallArrayt *self, int64_t value) {
8557 
8558  if (indexOfIntSmallArray(self, value) == -1) {
8559  return(false);
8560  }
8561 
8562  return(true);
8563 }
8564 
8565 internal bool hasSSmallArray(smallArrayt *self, const char *string) {
8566 
8567  if (!string) {
8568  return(false);
8569  }
8570 
8571  if (indexOfSSmallArray(self, string) == -1) {
8572  return(false);
8573  }
8574 
8575  return(true);
8576 }
8577 
8578 internal bool hasCharSmallArray(smallArrayt *self, char c) {
8579 
8580  charToS(s, c);
8581  return(hasSSmallArray(self, s));
8582 }
8583 
8584 internal bool hasDictSmallArray(smallArrayt *self, smallDictt *dict) {
8585 
8586  if (!dict) {
8587  return(false);
8588  }
8589 
8590  if (checkObjectTypes && !isOSmallDict(dict)) {
8591  return(false);
8592  }
8593 
8594  if (indexOfDictSmallArray(self, dict) == -1) {
8595  return(false);
8596  }
8597 
8598  return(true);
8599 }
8600 
8601 internal bool hasArraySmallArray(smallArrayt *self, smallArrayt *array) {
8602 
8603  if (!array) {
8604  return(false);
8605  }
8606 
8607  if (checkObjectTypes && !isOSmallArray(array)) {
8608  return(false);
8609  }
8610 
8611  if (indexOfArraySmallArray(self, array) == -1) {
8612  return(false);
8613  }
8614 
8615  return(true);
8616 }
8617 
8618 internal bool hasArraycSmallArray(smallArrayt *self, char **array) {
8619 
8620  if (!array) {
8621  return(false);
8622  }
8623 
8624  if (indexOfArraycSmallArray(self, array) == -1) {
8625  return(false);
8626  }
8627 
8628  return(true);
8629 }
8630 
8631 internal bool hasCArraycSmallArray(smallArrayt *self, const char **array) {
8632 
8633  if (!array) {
8634  return(false);
8635  }
8636 
8637  if (indexOfCArraycSmallArray(self, array) == -1) {
8638  return(false);
8639  }
8640 
8641  return(true);
8642 }
8643 
8644 internal bool hasSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
8645 
8646  if (!value) {
8647  return(false);
8648  }
8649 
8650  if (checkObjectTypes && !isOSmallBool(value)) {
8651  return(false);
8652  }
8653 
8654  if (indexOfSmallBoolSmallArray(self, value) == -1) {
8655  return(false);
8656  }
8657 
8658  return(true);
8659 }
8660 
8661 internal bool hasSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
8662 
8663  if (!value) {
8664  return(false);
8665  }
8666 
8667  if (checkObjectTypes && !isOSmallBytes(value)) {
8668  return(false);
8669  }
8670 
8671  if (indexOfSmallBytesSmallArray(self, value) == -1) {
8672  return(false);
8673  }
8674 
8675  return(true);
8676 }
8677 
8678 internal bool hasSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
8679 
8680  if (!value) {
8681  return(false);
8682  }
8683 
8684  if (checkObjectTypes && !isOSmallDouble(value)) {
8685  return(false);
8686  }
8687 
8688  if (indexOfSmallDoubleSmallArray(self, value) == -1) {
8689  return(false);
8690  }
8691 
8692  return(true);
8693 }
8694 
8695 internal bool hasSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
8696 
8697  if (!value) {
8698  return(false);
8699  }
8700 
8701  if (checkObjectTypes && !isOSmallInt(value)) {
8702  return(false);
8703  }
8704 
8705  if (indexOfSmallIntSmallArray(self, value) == -1) {
8706  return(false);
8707  }
8708 
8709  return(true);
8710 }
8711 
8712 internal bool hasSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
8713 
8714  if (!string) {
8715  return(false);
8716  }
8717 
8718  if (checkObjectTypes && !isOSmallJson(string)) {
8719  return(false);
8720  }
8721 
8722  if (indexOfSmallJsonSmallArray(self, string) == -1) {
8723  return(false);
8724  }
8725 
8726  return(true);
8727 }
8728 
8729 internal bool hasSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
8730 
8731  if (!string) {
8732  return(false);
8733  }
8734 
8735  if (checkObjectTypes && !isOSmallString(string)) {
8736  return(false);
8737  }
8738 
8739  if (indexOfSmallStringSmallArray(self, string) == -1) {
8740  return(false);
8741  }
8742 
8743  return(true);
8744 }
8745 
8746 internal bool hasSmallContainerSmallArray(smallArrayt *self, smallContainert *container) {
8747 
8748  if (!container) {
8749  return(false);
8750  }
8751 
8752  if (checkObjectTypes && !isOSmallContainer(container)) {
8753  return(NULL);
8754  }
8755 
8756  if (indexOfSmallContainerSmallArray(self, container) == -1) {
8757  return(false);
8758  }
8759 
8760  return(true);
8761 }
8762 
8763 internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value) {
8764 
8765  // sanity checks
8766  if (!lenSmallArray(self) || !value) {
8767  return(-1);
8768  }
8769 
8770  // search string in elements
8771  char *s = toStringO(value);
8772  char *es = NULL;
8773 
8774  enumerateSArray(self->a, e, i) {
8775  if (not e) {
8776  continue;
8777  }
8778  es = sToString(e);
8779  if (strEq(es, s)) {
8780  free(es);
8781  free(s);
8782  return((ssize_t)i);
8783  }
8784  free(es);
8785  }
8786  free(s);
8787  return(-1);
8788 }
8789 
8790 internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *u) {
8791 
8792  // sanity checks
8793  if (!lenSmallArray(self) || !u) {
8794  return(-1);
8795  }
8796 
8797  if (checkObjectTypes && !isOUndefined(u)) {
8798  return(-1);
8799  }
8800 
8801  // search string in elements
8802  enumerateSArray(self->a, e, i) {
8803  if (not e) {
8804  continue;
8805  }
8806  if (e->type == UNDEFINED) {
8807  return((ssize_t)i);
8808  }
8809  }
8810  return(-1);
8811 }
8812 
8813 internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value) {
8814 
8815  // sanity checks
8816  if (!lenSmallArray(self)) {
8817  return(-1);
8818  }
8819 
8820  // search value in elements
8821  enumerateSArray(self->a, e, i) {
8822  if (not e) {
8823  continue;
8824  }
8825  if (e->type == BOOL && ((sBoolt*)e)->value == value) {
8826  return((ssize_t)i);
8827  }
8828  }
8829  return(-1);
8830 }
8831 
8832 internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value) {
8833 
8834  // sanity checks
8835  if (!lenSmallArray(self)) {
8836  return(-1);
8837  }
8838 
8839  // search value in elements
8840  enumerateSArray(self->a, e, i) {
8841  if (not e) {
8842  continue;
8843  }
8844  if (e->type == DOUBLE && ((sDoublet*)e)->value == value) {
8845  return((ssize_t)i);
8846  }
8847  }
8848  return(-1);
8849 }
8850 
8851 internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value) {
8852 
8853  // sanity checks
8854  if (!lenSmallArray(self)) {
8855  return(-1);
8856  }
8857 
8858  // search value in elements
8859  enumerateSArray(self->a, e, i) {
8860  if (not e) {
8861  continue;
8862  }
8863  if (e->type == INT && ((sIntt*)e)->value == value) {
8864  return((ssize_t)i);
8865  }
8866  }
8867  return(-1);
8868 }
8869 
8870 internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string) {
8871 
8872  // sanity checks
8873  if (!lenSmallArray(self)) {
8874  return(-1);
8875  }
8876  if (!string) {
8877  return(-1);
8878  }
8879  // search string in elements
8880  enumerateSArray(self->a, e, i) {
8881  if (not e) {
8882  continue;
8883  }
8884  if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), string)) {
8885  return((ssize_t)i);
8886  }
8887  }
8888  return(-1);
8889 }
8890 
8891 internal ssize_t indexOfCharSmallArray(smallArrayt *self, char c) {
8892 
8893  charToS(s, c);
8894  return(indexOfSSmallArray(self, s));
8895 }
8896 
8897 internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict) {
8898 
8899  // sanity checks
8900  if (!lenSmallArray(self) || !dict) {
8901  return(-1);
8902  }
8903 
8904  if (checkObjectTypes && !isOSmallDict(dict)) {
8905  return(-1);
8906  }
8907 
8908  // search object in elements
8909  char *s = toStringO(dict);
8910  char *es = NULL;;
8911 
8912  enumerateSArray(self->a, e, i) {
8913  if (not e) {
8914  continue;
8915  }
8916  if (e->type == DICT) {
8917  es = sToString(e);
8918  if (strEq(es, s)) {
8919  free(es);
8920  free(s);
8921  return((ssize_t)i);
8922  }
8923  free(es);
8924  }
8925  }
8926  free(s);
8927  return(-1);
8928 }
8929 
8930 internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array) {
8931 
8932  // sanity checks
8933  if (!lenSmallArray(self) || !array) {
8934  return(-1);
8935  }
8936 
8937  if (checkObjectTypes && !isOSmallArray(array)) {
8938  return(-1);
8939  }
8940 
8941  // search object in elements
8942  char *s = toStringO(array);
8943  char *es = NULL;;
8944 
8945  enumerateSArray(self->a, e, i) {
8946  if (not e) {
8947  continue;
8948  }
8949  if (e->type == ARRAY) {
8950  es = sToString(e);
8951  if (strEq(es, s)) {
8952  free(es);
8953  free(s);
8954  return((ssize_t)i);
8955  }
8956  free(es);
8957  }
8958  }
8959  free(s);
8960  return(-1);
8961 }
8962 
8963 internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array) {
8964 
8965  // sanity checks
8966  if (!lenSmallArray(self) || !array) {
8967  return(-1);
8968  }
8969 
8970  // search object in elements
8971  char *s = toStringListSGF(array);
8972  char *es = NULL;;
8973 
8974  enumerateSArray(self->a, e, i) {
8975  if (not e) {
8976  continue;
8977  }
8978  if (e->type == ARRAY) {
8979  es = sToString(e);
8980  if (strEq(es, s)) {
8981  free(es);
8982  free(s);
8983  return((ssize_t)i);
8984  }
8985  free(es);
8986  }
8987  }
8988  free(s);
8989  return(-1);
8990 }
8991 
8992 internal ssize_t indexOfCArraycSmallArray(smallArrayt *self, const char **array) {
8993 
8994  // sanity checks
8995  if (!lenSmallArray(self) || !array) {
8996  return(-1);
8997  }
8998 
8999  // search object in elements
9000  char *s = toStringListCSGF(array);
9001  char *es = NULL;;
9002 
9003  enumerateSArray(self->a, e, i) {
9004  if (not e) {
9005  continue;
9006  }
9007  if (e->type == ARRAY) {
9008  es = sToString(e);
9009  if (strEq(es, s)) {
9010  free(es);
9011  free(s);
9012  return((ssize_t)i);
9013  }
9014  free(es);
9015  }
9016  }
9017  free(s);
9018  return(-1);
9019 }
9020 
9021 internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
9022 
9023  // sanity checks
9024  if (!lenSmallArray(self) || !value) {
9025  return(-1);
9026  }
9027 
9028  if (checkObjectTypes && !isOSmallBool(value)) {
9029  return(-1);
9030  }
9031 
9032  // search object in elements
9033  bool b = value->f->get(value);
9034 
9035  enumerateSArray(self->a, e, i) {
9036  if (not e) {
9037  continue;
9038  }
9039  if (e->type == BOOL && ((sBoolt*)e)->value == b) {
9040  return((ssize_t)i);
9041  }
9042  }
9043  return(-1);
9044 }
9045 
9046 internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
9047 
9048  // sanity checks
9049  if (!lenSmallArray(self) || !value || !value->B) {
9050  return(-1);
9051  }
9052 
9053  if (checkObjectTypes && !isOSmallBytes(value)) {
9054  return(-1);
9055  }
9056 
9057  // search object in elements
9058  void *b = sBytesGet(value->B);
9059  uint32_t count = value->B->count;
9060 
9061  enumerateSArray(self->a, e, i) {
9062  if (not e) {
9063  continue;
9064  }
9065  if (e->type == BYTES && ((sBytest*)e)->count == count && !memcmp(&(((sBytest*)e)->data), b, count)) {
9066  return((ssize_t)i);
9067  }
9068  }
9069  return(-1);
9070 }
9071 
9072 internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
9073 
9074  // sanity checks
9075  if (!lenSmallArray(self) || !value) {
9076  return(-1);
9077  }
9078 
9079  if (checkObjectTypes && !isOSmallDouble(value)) {
9080  return(-1);
9081  }
9082 
9083  // search object in elements
9084  double v = value->f->get(value);
9085 
9086  enumerateSArray(self->a, e, i) {
9087  if (not e) {
9088  continue;
9089  }
9090  if (e->type == DOUBLE && ((sDoublet*)e)->value == v) {
9091  return((ssize_t)i);
9092  }
9093  }
9094  return(-1);
9095 }
9096 
9097 internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
9098 
9099  // sanity checks
9100  if (!lenSmallArray(self) || !value) {
9101  return(-1);
9102  }
9103 
9104  if (checkObjectTypes && !isOSmallInt(value)) {
9105  return(-1);
9106  }
9107 
9108  // search object in elements
9109  int64_t v = value->f->get(value);
9110 
9111  enumerateSArray(self->a, e, i) {
9112  if (not e) {
9113  continue;
9114  }
9115  if (e->type == INT && ((sIntt*)e)->value == v) {
9116  return((ssize_t)i);
9117  }
9118  }
9119  return(-1);
9120 }
9121 
9122 internal ssize_t indexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
9123 
9124  if (!lenSmallArray(self) || !string) {
9125  return(-1);
9126  }
9127 
9128  if (checkObjectTypes && !isOSmallJson(string)) {
9129  return(-1);
9130  }
9131 
9132  const char *type = getTopTypeO(string);
9133 
9134  if (!type) {
9135  // smallJson is empty
9136  return(-1);
9137  }
9138 
9139  baset *O = NULL;
9140  ssize_t r = -1;
9141  if (eqS(type, "undefined")) {
9142  O = getTopO(string);
9143  r = indexOfSmallArray(self, O);
9144  finishO(O);
9145  }
9146  else if (eqS(type, "bool")) {
9147  O = getTopO(string);
9148  r = indexOfSmallBoolSmallArray(self, (smallBoolt*)O);
9149  finishO(O);
9150  }
9151  else if (eqS(type, "double")) {
9152  O = getTopO(string);
9153  r = indexOfSmallDoubleSmallArray(self, (smallDoublet*)O);
9154  finishO(O);
9155  }
9156  else if (eqS(type, "int")) {
9157  O = getTopO(string);
9158  r = indexOfSmallIntSmallArray(self, (smallIntt*)O);
9159  finishO(O);
9160  }
9161  else if (eqS(type, "string")) {
9162  O = getTopO(string);
9163  r = indexOfSmallStringSmallArray(self, (smallStringt*)O);
9164  finishO(O);
9165  }
9166  else if (eqS(type, "dict")) {
9167  O = getTopO(string);
9168  r = indexOfDictSmallArray(self, (smallDictt*)O);
9169  finishO(O);
9170  }
9171  else if (eqS(type, "array")) {
9172  O = getTopO(string);
9173  r = indexOfArraySmallArray(self, (smallArrayt*)O);
9174  finishO(O);
9175  }
9176  return(r);
9177 }
9178 
9179 
9180 internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
9181 
9182  // sanity checks
9183  if (!lenSmallArray(self)) {
9184  return(-1);
9185  }
9186 
9187  if (!string || !string->data) {
9188  return(-1);
9189  }
9190 
9191  if (checkObjectTypes && !isOSmallString(string)) {
9192  return(-1);
9193  }
9194 
9195  // search string in elements
9196  char *s = sStringGetTiny(string->data);
9197 
9198  enumerateSArray(self->a, e, i) {
9199  if (not e) {
9200  continue;
9201  }
9202  if (e->type == STRING && strEq(sStringGetTiny((sStringt*)e), s)) {
9203  return((ssize_t)i);
9204  }
9205  }
9206  return(-1);
9207 }
9208 
9209 internal ssize_t indexOfSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED) {
9210 
9211  // TODO
9212  return(-1);
9213 }
9214 
9215 internal ssize_t binarySearchSmallArray(smallArrayt *self, baset *value) {
9216  ssize_t first = 0, middle, last;;
9217 
9218  if (!lenSmallArray(self) || !value) {
9219  return(-1);
9220  }
9221 
9222  char *s = toStringO(value);
9223  char *m = NULL;
9224 
9225  ssize_t r = -1;
9226  last = (ssize_t)lenSmallArray(self) - 1;
9227  while (first <= last) {
9228  middle = (first+last)/2;
9229  m = sToString(sArrayGetTiny(self->a, (uint32_t)middle));
9230  if (!m) {
9231  // there are null element in the array
9232  // the array needs to be trimmed or compacted
9233  goto finish;
9234  }
9235  if (strcmp(m, s) < 0) {
9236  first = middle + 1;
9237  }
9238  else if (strcmp(m, s) == 0) {
9239  r = middle;
9240  free(m);
9241  goto finish;
9242  }
9243  else {
9244  last = middle -1;
9245  }
9246  free(m);
9247  }
9248  finish:
9249  free(s);
9250  return(r);
9251 }
9252 
9253 internal ssize_t binarySearchUndefinedSmallArray(smallArrayt *self UNUSED, undefinedt *u UNUSED) {
9254  // ssize_t first = 0, middle, last
9255 
9256  // it doesn't make sense to search for undefined
9257  // the array has to be sorted
9258  // so undefined is always at postion 0
9259  return(-1);
9260 
9261  // if !lenSmallArray(self) || !undefined
9262  // return -1
9263 
9264  // if checkObjectTypes && !isOUndefined(undefined)
9265  // return -1
9266 
9267  // smallt *m = NULL
9268 
9269  // ssize_t r = -1
9270  // last = lenSmallArray(self) - 1
9271  // while first <= last
9272  // middle = (first+last)/2
9273  // m = sArrayGetTiny(self->a, middle)
9274  // if !m
9275  // // there are null element in the array
9276  // // the array needs to be trimmed or compacted
9277  // return -1
9278  // if m->type < UNDEFINED
9279  // first = middle + 1
9280  // else if m->type = UNDEFINED
9281  // r = middle
9282  // goto finish;
9283  // else
9284  // last = middle -1
9285  // finish:
9286  // return r
9287 }
9288 
9289 internal ssize_t binarySearchBoolSmallArray(smallArrayt *self, bool value) {
9290  ssize_t first = 0, middle, last;;
9291 
9292  if (!lenSmallArray(self)) {
9293  return(-1);
9294  }
9295 
9296  sBoolt *m = NULL;
9297 
9298  ssize_t r = -1;
9299  last = (ssize_t)lenSmallArray(self) - 1;
9300  while (first <= last) {
9301  middle = (first+last)/2;
9302  m = (sBoolt*)(sArrayGetTiny(self->a, (uint32_t)middle));
9303  if (!m) {
9304  // there are null element in the array
9305  // the array needs to be trimmed or compacted
9306  return(-1);
9307  }
9308  if (m->type < BOOL || ((m->type == BOOL) && (m->value < value))) {
9309  first = middle + 1;
9310  }
9311  else if ((m->type == BOOL) && (m->value == value)) {
9312  r = middle;
9313  goto finish;
9314  }
9315  else {
9316  last = middle -1;
9317  }
9318  }
9319  finish:
9320  return(r);
9321 }
9322 
9323 
9324 internal ssize_t binarySearchDoubleSmallArray(smallArrayt *self, double value) {
9325  ssize_t first = 0, middle, last;;
9326 
9327  if (!lenSmallArray(self)) {
9328  return(-1);
9329  }
9330 
9331  sDoublet *m = NULL;
9332 
9333  ssize_t r = -1;
9334  last = (ssize_t)lenSmallArray(self) - 1;
9335  while (first <= last) {
9336  middle = (first+last)/2;
9337  m = (sDoublet*)(sArrayGetTiny(self->a, (uint32_t)middle));
9338  if (!m) {
9339  // there are null element in the array
9340  // the array needs to be trimmed or compacted
9341  return(-1);
9342  }
9343  if (m->type < DOUBLE || ((m->type == DOUBLE) && (m->value < value))) {
9344  first = middle + 1;
9345  }
9346  else if ((m->type == DOUBLE) && (m->value == value)) {
9347  r = middle;
9348  goto finish;
9349  }
9350  else {
9351  last = middle -1;
9352  }
9353  }
9354  finish:
9355  return(r);
9356 }
9357 
9358 internal ssize_t binarySearchIntSmallArray(smallArrayt *self, int64_t value) {
9359  ssize_t first = 0, middle, last;;
9360 
9361  if (!lenSmallArray(self)) {
9362  return(-1);
9363  }
9364 
9365  sIntt *m = NULL;
9366 
9367  ssize_t r = -1;
9368  last = (ssize_t)lenSmallArray(self) - 1;
9369  while (first <= last) {
9370  middle = (first+last)/2;
9371  m = (sIntt*)(sArrayGetTiny(self->a, (uint32_t)middle));
9372  if (!m) {
9373  // there are null element in the array
9374  // the array needs to be trimmed or compacted
9375  return(-1);
9376  }
9377  if (m->type < INT || ((m->type == INT) && (m->value < value))) {
9378  first = middle + 1;
9379  }
9380  else if ((m->type == INT) && (m->value == value)) {
9381  r = middle;
9382  goto finish;
9383  }
9384  else {
9385  last = middle -1;
9386  }
9387  }
9388  finish:
9389  return(r);
9390 }
9391 
9392 internal ssize_t binarySearchSSmallArray(smallArrayt *self, const char *string) {
9393  ssize_t first = 0, middle, last;;
9394 
9395  if (!lenSmallArray(self) || !string) {
9396  return(-1);
9397  }
9398 
9399  smallt *e = NULL;
9400 
9401  last = (ssize_t)lenSmallArray(self) - 1;
9402  while (first <= last) {
9403  middle = (first+last)/2;
9404  e = sArrayGetTiny(self->a, (uint32_t)middle);
9405  if (!e) {
9406  // there are null element in the array
9407  // the array needs to be trimmed or compacted
9408  return(-1);
9409  }
9410  char *m = sStringGetTiny((sStringt*)(e));
9411  if (e->type < STRING || ((e->type == STRING) && (strcmp(m, string) < 0))) {
9412  first = middle + 1;
9413  }
9414  else if ((e->type == STRING) && (strcmp(m, string) == 0)) {
9415  return(middle);
9416  }
9417  else {
9418  last = middle -1;
9419  }
9420  }
9421  return(-1);
9422 }
9423 
9424 internal ssize_t binarySearchCharSmallArray(smallArrayt *self, char c) {
9425 
9426  charToS(s, c);
9427  return(binarySearchSSmallArray(self, s));
9428 }
9429 
9430 internal ssize_t binarySearchDictSmallArray(smallArrayt *self, smallDictt *dict) {
9431  ssize_t first = 0, middle, last;;
9432 
9433  if (!lenSmallArray(self) || !dict) {
9434  return(-1);
9435  }
9436 
9437  if (checkObjectTypes && !isOSmallDict(dict)) {
9438  return(-1);
9439  }
9440 
9441  char *s = toStringO(dict);
9442  smallt *e = NULL;
9443  char *m = NULL;
9444 
9445  ssize_t r = -1;
9446  last = (ssize_t)lenSmallArray(self) - 1;
9447  while (first <= last) {
9448  middle = (first+last)/2;
9449  e = sArrayGetTiny(self->a, (uint32_t)middle);
9450  if (!e) {
9451  // there are null element in the array
9452  // the array needs to be trimmed or compacted
9453  goto finish;
9454  }
9455  // cg_c bug, can't use comma operator, extra code
9456  if (e->type == DICT) {
9457  m = sToString(e);
9458  }
9459  // cg_c bug, can't use comma operator
9460  /* if e->type < DICT || ((e->type = DICT) && strcmp((m=sToString(e),m), s) < 0) */
9461  if (e->type < DICT || ((e->type == DICT) && strcmp(m, s) < 0)) {
9462  first = middle + 1;
9463  }
9464  else if ((e->type == DICT) && strcmp(m, s) == 0) {
9465  r = middle;
9466  free(m);
9467  goto finish;
9468  }
9469  else {
9470  last = middle -1;
9471  }
9472  if (e->type == DICT) {
9473  free(m);
9474  }
9475  }
9476  finish:
9477  free(s);
9478  return(r);
9479 }
9480 
9481 internal ssize_t binarySearchArraySmallArray(smallArrayt *self, smallArrayt *array) {
9482  ssize_t first = 0, middle, last;;
9483 
9484  if (!lenSmallArray(self) || !array) {
9485  return(-1);
9486  }
9487 
9488  if (checkObjectTypes && !isOSmallArray(array)) {
9489  return(-1);
9490  }
9491 
9492  char *s = toStringO(array);
9493  smallt *e = NULL;
9494  char *m = NULL;
9495 
9496  ssize_t r = -1;
9497  last = (ssize_t)lenSmallArray(self) - 1;
9498  while (first <= last) {
9499  middle = (first+last)/2;
9500  e = sArrayGetTiny(self->a, (uint32_t)middle);
9501  if (!e) {
9502  // there are null element in the array
9503  // the array needs to be trimmed or compacted
9504  goto finish;
9505  }
9506  // cg_c bug, can't use comma operator, extra code
9507  if (e->type == ARRAY) {
9508  m = sToString(e);
9509  }
9510  // cg_c bug, can't use comma operator
9511  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
9512  if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) {
9513  first = middle + 1;
9514  }
9515  else if ((e->type == ARRAY) && strcmp(m, s) == 0) {
9516  r = middle;
9517  free(m);
9518  goto finish;
9519  }
9520  else {
9521  last = middle -1;
9522  }
9523  if (e->type == ARRAY) {
9524  free(m);
9525  }
9526  }
9527  finish:
9528  free(s);
9529  return(r);
9530 }
9531 
9532 internal ssize_t binarySearchArraycSmallArray(smallArrayt *self, char **array) {
9533  ssize_t first = 0, middle, last;;
9534 
9535  if (!lenSmallArray(self) || !array) {
9536  return(-1);
9537  }
9538 
9539  char *s = toStringListSGF(array);
9540  smallt *e = NULL;
9541  char *m = NULL;
9542 
9543  ssize_t r = -1;
9544  last = (ssize_t)lenSmallArray(self) - 1;
9545  while (first <= last) {
9546  middle = (first+last)/2;
9547  e = sArrayGetTiny(self->a, (uint32_t)middle);
9548  if (!e) {
9549  // there are null element in the array
9550  // the array needs to be trimmed or compacted
9551  goto finish;
9552  }
9553  // cg_c bug, can't use comma operator, extra code
9554  if (e->type == ARRAY) {
9555  m = sToString(e);
9556  }
9557  // cg_c bug, can't use comma operator
9558  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
9559  if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) {
9560  first = middle + 1;
9561  }
9562  else if ((e->type == ARRAY) && strcmp(m, s) == 0) {
9563  r = middle;
9564  free(m);
9565  goto finish;
9566  }
9567  else {
9568  last = middle -1;
9569  }
9570  if (e->type == ARRAY) {
9571  free(m);
9572  }
9573  }
9574  finish:
9575  free(s);
9576  return(r);
9577 }
9578 
9579 internal ssize_t binarySearchCArraycSmallArray(smallArrayt *self, const char **array) {
9580  ssize_t first = 0, middle, last;;
9581 
9582  if (!lenSmallArray(self) || !array) {
9583  return(-1);
9584  }
9585 
9586  char *s = toStringListCSGF(array);
9587  smallt *e = NULL;
9588  char *m = NULL;
9589 
9590  ssize_t r = -1;
9591  last = (ssize_t)lenSmallArray(self) - 1;
9592  while (first <= last) {
9593  middle = (first+last)/2;
9594  e = sArrayGetTiny(self->a, (uint32_t)middle);
9595  if (!e) {
9596  // there are null element in the array
9597  // the array needs to be trimmed or compacted
9598  goto finish;
9599  }
9600  // cg_c bug, can't use comma operator, extra code
9601  if (e->type == ARRAY) {
9602  m = sToString(e);
9603  }
9604  // cg_c bug, can't use comma operator
9605  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
9606  if (e->type < ARRAY || ((e->type == ARRAY) && strcmp(m, s) < 0)) {
9607  first = middle + 1;
9608  }
9609  else if ((e->type == ARRAY) && strcmp(m, s) == 0) {
9610  r = middle;
9611  free(m);
9612  goto finish;
9613  }
9614  else {
9615  last = middle -1;
9616  }
9617  if (e->type == ARRAY) {
9618  free(m);
9619  }
9620  }
9621  finish:
9622  free(s);
9623  return(r);
9624 }
9625 
9626 internal ssize_t binarySearchSmallBoolSmallArray(smallArrayt *self, smallBoolt *value) {
9627  ssize_t first = 0, middle, last;;
9628 
9629  if (!lenSmallArray(self) || !value) {
9630  return(-1);
9631  }
9632 
9633  if (checkObjectTypes && !isOSmallBool(value)) {
9634  return(-1);
9635  }
9636 
9637  bool b = value->f->get(value);
9638  sBoolt *m = NULL;
9639 
9640  ssize_t r = -1;
9641  last = (ssize_t)lenSmallArray(self) - 1;
9642  while (first <= last) {
9643  middle = (first+last)/2;
9644  m = (sBoolt*)(sArrayGetTiny(self->a, (uint32_t)middle));
9645  if (!m) {
9646  // there are null element in the array
9647  // the array needs to be trimmed or compacted
9648  goto finish;
9649  }
9650  if (m->type < BOOL || ((m->type == BOOL) && (m->value < b))) {
9651  first = middle + 1;
9652  }
9653  else if ((m->type == BOOL) && (m->value == b)) {
9654  r = middle;
9655  goto finish;
9656  }
9657  else {
9658  last = middle -1;
9659  }
9660  }
9661  finish:
9662  return(r);
9663 }
9664 
9665 internal ssize_t binarySearchSmallBytesSmallArray(smallArrayt *self, smallBytest *value) {
9666  ssize_t first = 0, middle, last;;
9667 
9668  if (!lenSmallArray(self) || !value || !value->B) {
9669  return(-1);
9670  }
9671 
9672  if (checkObjectTypes && !isOSmallBytes(value)) {
9673  return(-1);
9674  }
9675 
9676  void *b = sBytesGet(value->B);
9677  uint32_t count = value->B->count;
9678  sBytest *m = NULL;
9679 
9680  ssize_t r = -1;
9681  last = (ssize_t)lenSmallArray(self) - 1;
9682  while (first <= last) {
9683  middle = (first+last)/2;
9684  m = (sBytest*)(sArrayGetTiny(self->a, (uint32_t)middle));
9685  if (!m) {
9686  // there are null element in the array
9687  // the array needs to be trimmed or compacted
9688  goto finish;
9689  }
9690  if (m->type < BYTES || ((m->type == BYTES) && ((m->count < count) || (memcmp(&m->data, b, count) < 0)))) {
9691  first = middle + 1;
9692  }
9693  else if ((m->type == BYTES) && (m->count == count) && !memcmp(&m->data, b, count)) {
9694  r = middle;
9695  goto finish;
9696  }
9697  else {
9698  last = middle -1;
9699  }
9700  }
9701  finish:
9702  return(r);
9703 }
9704 
9705 internal ssize_t binarySearchSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value) {
9706  ssize_t first = 0, middle, last;;
9707 
9708  if (!lenSmallArray(self) || !value) {
9709  return(-1);
9710  }
9711 
9712  if (checkObjectTypes && !isOSmallDouble(value)) {
9713  return(-1);
9714  }
9715 
9716  double v = value->f->get(value);
9717  sDoublet *m = NULL;
9718 
9719  ssize_t r = -1;
9720  last = (ssize_t)lenSmallArray(self) - 1;
9721  while (first <= last) {
9722  middle = (first+last)/2;
9723  m = (sDoublet*)(sArrayGetTiny(self->a, (uint32_t)middle));
9724  if (!m) {
9725  // there are null element in the array
9726  // the array needs to be trimmed or compacted
9727  goto finish;
9728  }
9729  if (m->type < DOUBLE || ((m->type == DOUBLE) && (m->value < v))) {
9730  first = middle + 1;
9731  }
9732  else if ((m->type == DOUBLE) && (m->value == v)) {
9733  r = middle;
9734  goto finish;
9735  }
9736  else {
9737  last = middle -1;
9738  }
9739  }
9740  finish:
9741  return(r);
9742 }
9743 
9744 internal ssize_t binarySearchSmallIntSmallArray(smallArrayt *self, smallIntt *value) {
9745  ssize_t first = 0, middle, last;;
9746 
9747  if (!lenSmallArray(self) || !value) {
9748  return(-1);
9749  }
9750 
9751  if (checkObjectTypes && !isOSmallInt(value)) {
9752  return(-1);
9753  }
9754 
9755  int64_t v = value->f->get(value);
9756  sIntt *m = NULL;
9757 
9758  ssize_t r = -1;
9759  last = (ssize_t)lenSmallArray(self) - 1;
9760  while (first <= last) {
9761  middle = (first+last)/2;
9762  m = (sIntt*)(sArrayGetTiny(self->a, (uint32_t)middle));
9763  if (!m) {
9764  // there are null element in the array
9765  // the array needs to be trimmed or compacted
9766  goto finish;
9767  }
9768  if (m->type < INT || ((m->type == INT) && (m->value < v))) {
9769  first = middle + 1;
9770  }
9771  else if ((m->type == INT) && (m->value == v)) {
9772  r = middle;
9773  goto finish;
9774  }
9775  else {
9776  last = middle -1;
9777  }
9778  }
9779  finish:
9780  return(r);
9781 }
9782 
9783 internal ssize_t binarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
9784 
9785  if (!lenSmallArray(self) || !string) {
9786  return(-1);
9787  }
9788 
9789  if (checkObjectTypes && !isOSmallJson(string)) {
9790  return(-1);
9791  }
9792 
9793  const char *type = getTopTypeO(string);
9794 
9795  if (!type) {
9796  // smallJson is empty
9797  return(-1);
9798  }
9799 
9800  baset *O = NULL;
9801  ssize_t r = -1;
9802  if (eqS(type, "undefined")) {
9803  // it doesn't make sense to search for undefined
9804  // the array has to be sorted
9805  // so undefined is always at postion 0
9806  return(-1);
9807  }
9808  else if (eqS(type, "bool")) {
9809  O = getTopO(string);
9810  r = binarySearchSmallBoolSmallArray(self, (smallBoolt*)O);
9811  finishO(O);
9812  }
9813  else if (eqS(type, "double")) {
9814  O = getTopO(string);
9815  r = binarySearchSmallDoubleSmallArray(self, (smallDoublet*)O);
9816  finishO(O);
9817  }
9818  else if (eqS(type, "int")) {
9819  O = getTopO(string);
9820  r = binarySearchSmallIntSmallArray(self, (smallIntt*)O);
9821  finishO(O);
9822  }
9823  else if (eqS(type, "string")) {
9824  O = getTopO(string);
9825  r = binarySearchSmallStringSmallArray(self, (smallStringt*)O);
9826  finishO(O);
9827  }
9828  else if (eqS(type, "dict")) {
9829  O = getTopO(string);
9830  r = binarySearchDictSmallArray(self, (smallDictt*)O);
9831  finishO(O);
9832  }
9833  else if (eqS(type, "array")) {
9834  O = getTopO(string);
9835  r = binarySearchArraySmallArray(self, (smallArrayt*)O);
9836  finishO(O);
9837  }
9838  return(r);
9839 }
9840 
9841 internal ssize_t binarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
9842  ssize_t first = 0, middle, last;;
9843 
9844  if (!lenSmallArray(self) || !string || !string->data) {
9845  return(-1);
9846  }
9847 
9848  char *s = sStringGetTiny(string->data);
9849  smallt *e = NULL;
9850 
9851  if (checkObjectTypes && !isOSmallString(string)) {
9852  return(-1);
9853  }
9854 
9855  last = (ssize_t)lenSmallArray(self) - 1;
9856  while (first <= last) {
9857  middle = (first+last)/2;
9858  e = sArrayGetTiny(self->a, (uint32_t)middle);
9859  if (!e) {
9860  // there are null element in the array
9861  // the array needs to be trimmed or compacted
9862  return(-1);
9863  }
9864  char *m = sStringGetTiny((sStringt*)(e));
9865  if (e->type < STRING || ((e->type == STRING) && (strcmp(m, s) < 0))) {
9866  first = middle + 1;
9867  }
9868  else if ((e->type == STRING) && (strcmp(m, s) == 0)) {
9869  return(middle);
9870  }
9871  else {
9872  last = middle -1;
9873  }
9874  }
9875  return(-1);
9876 }
9877 
9878 internal ssize_t binarySearchSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED) {
9879 
9880  // TODO
9881  return(-1);
9882 }
9883 
9884 
9885 
9886 
9887 
9888 internal smallArrayt* uniqSmallArray(smallArrayt *self) {
9889 
9890  // sanity checks
9891  if (!lenSmallArray(self)) {
9892  return(NULL);
9893  }
9894 
9895  if (lenSmallArray(self) == 1) {
9896  return(self);
9897  }
9898 
9899  createAllocateSmallArray(r);
9900  if (!r) {
9901  return(NULL);
9902  }
9903  createAllocateSmallArray(a);
9904  if (!a) {
9905  terminateO(r);
9906  return(NULL);
9907  }
9908  createAllocateSmallDict(d);
9909  if (!d) {
9910  terminateO(r);
9911  terminateO(a);
9912  return(NULL);
9913  }
9914  createAllocateSmallBytes(B);
9915  if (!B) {
9916  terminateO(r);
9917  terminateO(a);
9918  terminateO(B);
9919  return(NULL);
9920  }
9921 
9922  // push element to new list if it is not already in new list
9923  bool pushE = false;
9924  bool foundUndefined = false;
9925  forEachSArray(self->a, e) {
9926  if (e) {
9927  switch (e->type) {
9928  case UNDEFINED:
9929  if (!foundUndefined) {
9930  pushE = true;
9931  foundUndefined = true;
9932  }
9933  else {
9934  free(e);
9935  }
9936  break;
9937  case BOOL:
9938  if (r->f->indexOfBool(r, ((sBoolt*)e)->value) == -1) {
9939  pushE = true;
9940  }
9941  else {
9942  free(e);
9943  }
9944  break;
9945  // TODO case CONTAINER:
9946  case DICT:
9947  d->d = (sDictt*)e;
9948  if (r->f->indexOfDict(r, d) == -1) {
9949  pushE = true;
9950  }
9951  else {
9952  freeO(d);
9953  }
9954  break;
9955  case DOUBLE:
9956  if (r->f->indexOfDouble(r, ((sDoublet*)e)->value) == -1) {
9957  pushE = true;
9958  }
9959  else {
9960  free(e);
9961  }
9962  break;
9963  case INT:
9964  if (r->f->indexOfInt(r, ((sIntt*)e)->value) == -1) {
9965  pushE = true;
9966  }
9967  else {
9968  free(e);
9969  }
9970  break;
9971  case STRING:
9972  if (r->f->indexOfS(r, sStringGetTiny((sStringt*)e)) == -1) {
9973  pushE = true;
9974  }
9975  else {
9976  free(e);
9977  }
9978  break;
9979  case ARRAY:
9980  a->a = (sArrayt*)e;
9981  if (r->f->indexOfArray(r, a) == -1) {
9982  pushE = true;
9983  }
9984  else {
9985  freeO(a);
9986  }
9987  break;
9988  case BYTES:
9989  B->B = (sBytest*)e;
9990  if (r->f->indexOfSmallBytes(r, B) == -1) {
9991  pushE = true;
9992  }
9993  else {
9994  freeO(B);
9995  }
9996  break;
9997  default:
9998  logC("Unsupported object type!");
9999  }
10000  }
10001  if (pushE) {
10002  sArrayPushTiny(&(r->a), e);
10003  pushE = false;
10004  }
10005  }
10006 
10007  finishManyG(a, d, B);
10008 
10009  free(self->a);
10010  self->a = r->a;
10011  finishO(r);
10012  return(self);
10013 }
10014 
10015 
10016 internal bool icHasSmallArray(smallArrayt *self, baset *value) {
10017 
10018  if (!value) {
10019  return(false);
10020  }
10021 
10022  if (icIndexOfSmallArray(self, value) == -1) {
10023  return(false);
10024  }
10025 
10026  return(true);
10027 }
10028 
10029 internal bool icHasSSmallArray(smallArrayt *self, const char *string) {
10030 
10031  if (!string) {
10032  return(false);
10033  }
10034 
10035  if (icIndexOfSSmallArray(self, string) == -1) {
10036  return(false);
10037  }
10038 
10039  return(true);
10040 }
10041 
10042 internal bool icHasCharSmallArray(smallArrayt *self, char c) {
10043 
10044  charToS(s, c);
10045  return(icHasSSmallArray(self, s));
10046 }
10047 
10048 internal bool icHasDictSmallArray(smallArrayt *self, smallDictt *dict) {
10049 
10050  if (!dict) {
10051  return(false);
10052  }
10053 
10054  if (icIndexOfDictSmallArray(self, dict) == -1) {
10055  return(false);
10056  }
10057 
10058  return(true);
10059 }
10060 
10061 internal bool icHasArraySmallArray(smallArrayt *self, smallArrayt *array) {
10062 
10063  if (!array) {
10064  return(false);
10065  }
10066 
10067  if (icIndexOfArraySmallArray(self, array) == -1) {
10068  return(false);
10069  }
10070 
10071  return(true);
10072 }
10073 
10074 internal bool icHasArraycSmallArray(smallArrayt *self, char **array) {
10075 
10076  if (!array) {
10077  return(false);
10078  }
10079 
10080  if (icIndexOfArraycSmallArray(self, array) == -1) {
10081  return(false);
10082  }
10083 
10084  return(true);
10085 }
10086 
10087 internal bool icHasCArraycSmallArray(smallArrayt *self, const char **array) {
10088 
10089  if (!array) {
10090  return(false);
10091  }
10092 
10093  if (icIndexOfCArraycSmallArray(self, array) == -1) {
10094  return(false);
10095  }
10096 
10097  return(true);
10098 }
10099 
10100 internal bool icHasSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
10101 
10102  if (!string) {
10103  return(false);
10104  }
10105 
10106  if (icIndexOfSmallJsonSmallArray(self, string) == -1) {
10107  return(false);
10108  }
10109 
10110  return(true);
10111 }
10112 
10113 internal bool icHasSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
10114 
10115  if (!string) {
10116  return(false);
10117  }
10118 
10119  if (icIndexOfSmallStringSmallArray(self, string) == -1) {
10120  return(false);
10121  }
10122 
10123  return(true);
10124 }
10125 
10126 internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value) {
10127 
10128  // sanity checks
10129  if (!lenSmallArray(self) || !value) {
10130  return(-1);
10131  }
10132 
10133  // search string in elements
10134  char *s = toStringO(value);
10135  char *es = NULL;
10136 
10137  enumerateSArray(self->a, e, i) {
10138  if (not e) {
10139  continue;
10140  }
10141  es = sToString(e);
10142  if (icEqS(es, s)) {
10143  free(es);
10144  free(s);
10145  return((ssize_t)i);
10146  }
10147  free(es);
10148  }
10149  free(s);
10150  return(-1);
10151 }
10152 
10153 internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string) {
10154 
10155  // sanity checks
10156  if (!lenSmallArray(self)) {
10157  return(-1);
10158  }
10159  if (!string) {
10160  return(-1);
10161  }
10162  // search string in elements
10163  enumerateSArray(self->a, e, i) {
10164  if (not e) {
10165  continue;
10166  }
10167  if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), string)) {
10168  return((ssize_t)i);
10169  }
10170  }
10171  return(-1);
10172 }
10173 
10174 internal ssize_t icIndexOfCharSmallArray(smallArrayt *self, char c) {
10175 
10176  charToS(s, c);
10177  return(icIndexOfSSmallArray(self, s));
10178 }
10179 
10180 internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict) {
10181 
10182  // sanity checks
10183  if (!lenSmallArray(self) || !dict) {
10184  return(-1);
10185  }
10186 
10187  if (checkObjectTypes && !isOSmallDict(dict)) {
10188  return(-1);
10189  }
10190 
10191  // search object in elements
10192  char *s = toStringO(dict);
10193  char *es = NULL;;
10194 
10195  enumerateSArray(self->a, e, i) {
10196  if (not e) {
10197  continue;
10198  }
10199  if (e->type == DICT) {
10200  es = sToString(e);
10201  if (icEqS(es, s)) {
10202  free(es);
10203  free(s);
10204  return((ssize_t)i);
10205  }
10206  free(es);
10207  }
10208  }
10209  free(s);
10210  return(-1);
10211 }
10212 
10213 internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array) {
10214 
10215  // sanity checks
10216  if (!lenSmallArray(self) || !array) {
10217  return(-1);
10218  }
10219 
10220  if (checkObjectTypes && !isOSmallArray(array)) {
10221  return(-1);
10222  }
10223 
10224  // search object in elements
10225  char *s = toStringO(array);
10226  char *es = NULL;;
10227 
10228  enumerateSArray(self->a, e, i) {
10229  if (not e) {
10230  continue;
10231  }
10232  if (e->type == ARRAY) {
10233  es = sToString(e);
10234  if (icEqS(es, s)) {
10235  free(es);
10236  free(s);
10237  return((ssize_t)i);
10238  }
10239  free(es);
10240  }
10241  }
10242  free(s);
10243  return(-1);
10244 }
10245 
10246 internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array) {
10247 
10248  // sanity checks
10249  if (!lenSmallArray(self) || !array) {
10250  return(-1);
10251  }
10252 
10253  // search object in elements
10254  char *s = toStringListSGF(array);
10255  char *es = NULL;;
10256 
10257  enumerateSArray(self->a, e, i) {
10258  if (not e) {
10259  continue;
10260  }
10261  if (e->type == ARRAY) {
10262  es = sToString(e);
10263  if (icEqS(es, s)) {
10264  free(es);
10265  free(s);
10266  return((ssize_t)i);
10267  }
10268  free(es);
10269  }
10270  }
10271  free(s);
10272  return(-1);
10273 }
10274 
10275 internal ssize_t icIndexOfCArraycSmallArray(smallArrayt *self, const char **array) {
10276 
10277  // sanity checks
10278  if (!lenSmallArray(self) || !array) {
10279  return(-1);
10280  }
10281 
10282  // search object in elements
10283  char *s = toStringListCSGF(array);
10284  char *es = NULL;;
10285 
10286  enumerateSArray(self->a, e, i) {
10287  if (not e) {
10288  continue;
10289  }
10290  if (e->type == ARRAY) {
10291  es = sToString(e);
10292  if (icEqS(es, s)) {
10293  free(es);
10294  free(s);
10295  return((ssize_t)i);
10296  }
10297  free(es);
10298  }
10299  }
10300  free(s);
10301  return(-1);
10302 }
10303 
10304 internal ssize_t icIndexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
10305 
10306  if (!lenSmallArray(self) || !string) {
10307  return(-1);
10308  }
10309 
10310  if (checkObjectTypes && !isOSmallJson(string)) {
10311  return(-1);
10312  }
10313 
10314  const char *type = getTopTypeO(string);
10315 
10316  if (!type) {
10317  // smallJson is empty
10318  return(-1);
10319  }
10320 
10321  baset *O = NULL;
10322  ssize_t r = -1;
10323  if (eqS(type, "undefined")) {
10324  O = getTopO(string);
10325  r = indexOfSmallArray(self, O);
10326  finishO(O);
10327  }
10328  else if (eqS(type, "bool")) {
10329  O = getTopO(string);
10330  r = indexOfSmallBoolSmallArray(self, (smallBoolt*)O);
10331  finishO(O);
10332  }
10333  else if (eqS(type, "double")) {
10334  O = getTopO(string);
10335  r = indexOfSmallDoubleSmallArray(self, (smallDoublet*)O);
10336  finishO(O);
10337  }
10338  else if (eqS(type, "int")) {
10339  O = getTopO(string);
10340  r = indexOfSmallIntSmallArray(self, (smallIntt*)O);
10341  finishO(O);
10342  }
10343  else if (eqS(type, "string")) {
10344  O = getTopO(string);
10345  r = icIndexOfSmallStringSmallArray(self, (smallStringt*)O);
10346  finishO(O);
10347  }
10348  else if (eqS(type, "dict")) {
10349  O = getTopO(string);
10350  r = icIndexOfDictSmallArray(self, (smallDictt*)O);
10351  finishO(O);
10352  }
10353  else if (eqS(type, "array")) {
10354  O = getTopO(string);
10355  r = icIndexOfArraySmallArray(self, (smallArrayt*)O);
10356  finishO(O);
10357  }
10358  return(r);
10359 }
10360 
10361 internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
10362 
10363  // sanity checks
10364  if (!lenSmallArray(self)) {
10365  return(-1);
10366  }
10367 
10368  if (!string || !string->data) {
10369  return(-1);
10370  }
10371 
10372  if (checkObjectTypes && !isOSmallString(string)) {
10373  return(-1);
10374  }
10375 
10376  // search string in elements
10377  char *s = sStringGetTiny(string->data);
10378 
10379  enumerateSArray(self->a, e, i) {
10380  if (not e) {
10381  continue;
10382  }
10383  if (e->type == STRING && icEqS(sStringGetTiny((sStringt*)e), s)) {
10384  return((ssize_t)i);
10385  }
10386  }
10387  return(-1);
10388 }
10389 
10390 internal ssize_t icBinarySearchSmallArray(smallArrayt *self, baset *value) {
10391  ssize_t first = 0, middle, last;;
10392 
10393  if (!lenSmallArray(self) || !value) {
10394  return(-1);
10395  }
10396 
10397  char *s = toStringO(value);
10398  char *m = NULL;
10399 
10400  ssize_t r = -1;
10401  last = (ssize_t)lenSmallArray(self) - 1;
10402  while (first <= last) {
10403  middle = (first+last)/2;
10404  m = sToString(sArrayGetTiny(self->a, (uint32_t)middle));
10405  if (!m) {
10406  // there are null element in the array
10407  // the array needs to be trimmed or compacted
10408  goto finish;
10409  }
10410  if (strcasecmp(m, s) < 0) {
10411  first = middle + 1;
10412  }
10413  else if (strcasecmp(m, s) == 0) {
10414  r = middle;
10415  free(m);
10416  goto finish;
10417  }
10418  else {
10419  last = middle -1;
10420  }
10421  free(m);
10422  }
10423  finish:
10424  free(s);
10425  return(r);
10426 }
10427 
10428 internal ssize_t icBinarySearchSSmallArray(smallArrayt *self, const char *string) {
10429  ssize_t first = 0, middle, last;;
10430 
10431  if (!lenSmallArray(self) || !string) {
10432  return(-1);
10433  }
10434 
10435  smallt *e = NULL;
10436 
10437  last = (ssize_t)lenSmallArray(self) - 1;
10438  while (first <= last) {
10439  middle = (first+last)/2;
10440  e = sArrayGetTiny(self->a, (uint32_t)middle);
10441  if (!e) {
10442  // there are null element in the array
10443  // the array needs to be trimmed or compacted
10444  return(-1);
10445  }
10446  char *m = sStringGetTiny((sStringt*)(e));
10447  if (e->type < STRING || ((e->type == STRING) && (strcasecmp(m, string) < 0))) {
10448  first = middle + 1;
10449  }
10450  else if ((e->type == STRING) && (strcasecmp(m, string) == 0)) {
10451  return(middle);
10452  }
10453  else {
10454  last = middle -1;
10455  }
10456  }
10457  return(-1);
10458 }
10459 
10460 internal ssize_t icBinarySearchCharSmallArray(smallArrayt *self, char c) {
10461 
10462  charToS(s, c);
10463  return(icBinarySearchSSmallArray(self, s));
10464 }
10465 
10466 internal ssize_t icBinarySearchDictSmallArray(smallArrayt *self, smallDictt *dict) {
10467  ssize_t first = 0, middle, last;;
10468 
10469  if (!lenSmallArray(self) || !dict) {
10470  return(-1);
10471  }
10472 
10473  if (checkObjectTypes && !isOSmallDict(dict)) {
10474  return(-1);
10475  }
10476 
10477  char *s = toStringO(dict);
10478  smallt *e = NULL;
10479  char *m = NULL;
10480 
10481  ssize_t r = -1;
10482  last = (ssize_t)lenSmallArray(self) - 1;
10483  while (first <= last) {
10484  middle = (first+last)/2;
10485  e = sArrayGetTiny(self->a, (uint32_t)middle);
10486  if (!e) {
10487  // there are null element in the array
10488  // the array needs to be trimmed or compacted
10489  goto finish;
10490  }
10491  // cg_c bug, can't use comma operator, extra code
10492  if (e->type == DICT) {
10493  m = sToString(e);
10494  }
10495  // cg_c bug, can't use comma operator
10496  /* if e->type < DICT || ((e->type = DICT) && strcmp((m=sToString(e),m), s) < 0) */
10497  if (e->type < DICT || ((e->type == DICT) && strcasecmp(m, s) < 0)) {
10498  first = middle + 1;
10499  }
10500  else if ((e->type == DICT) && strcasecmp(m, s) == 0) {
10501  r = middle;
10502  free(m);
10503  goto finish;
10504  }
10505  else {
10506  last = middle -1;
10507  }
10508  if (e->type == DICT) {
10509  free(m);
10510  }
10511  }
10512  finish:
10513  free(s);
10514  return(r);
10515 }
10516 
10517 internal ssize_t icBinarySearchArraySmallArray(smallArrayt *self, smallArrayt *array) {
10518  ssize_t first = 0, middle, last;;
10519 
10520  if (!lenSmallArray(self) || !array) {
10521  return(-1);
10522  }
10523 
10524  if (checkObjectTypes && !isOSmallArray(array)) {
10525  return(-1);
10526  }
10527 
10528  char *s = toStringO(array);
10529  smallt *e = NULL;
10530  char *m = NULL;
10531 
10532  ssize_t r = -1;
10533  last = (ssize_t)lenSmallArray(self) - 1;
10534  while (first <= last) {
10535  middle = (first+last)/2;
10536  e = sArrayGetTiny(self->a, (uint32_t)middle);
10537  if (!e) {
10538  // there are null element in the array
10539  // the array needs to be trimmed or compacted
10540  goto finish;
10541  }
10542  // cg_c bug, can't use comma operator, extra code
10543  if (e->type == ARRAY) {
10544  m = sToString(e);
10545  }
10546  // cg_c bug, can't use comma operator
10547  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
10548  if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) {
10549  first = middle + 1;
10550  }
10551  else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) {
10552  r = middle;
10553  free(m);
10554  goto finish;
10555  }
10556  else {
10557  last = middle -1;
10558  }
10559  if (e->type == ARRAY) {
10560  free(m);
10561  }
10562  }
10563  finish:
10564  free(s);
10565  return(r);
10566 }
10567 
10568 internal ssize_t icBinarySearchArraycSmallArray(smallArrayt *self, char **array) {
10569  ssize_t first = 0, middle, last;;
10570 
10571  if (!lenSmallArray(self) || !array) {
10572  return(-1);
10573  }
10574 
10575  char *s = toStringListSGF(array);
10576  smallt *e = NULL;
10577  char *m = NULL;
10578 
10579  ssize_t r = -1;
10580  last = (ssize_t)lenSmallArray(self) - 1;
10581  while (first <= last) {
10582  middle = (first+last)/2;
10583  e = sArrayGetTiny(self->a, (uint32_t)middle);
10584  if (!e) {
10585  // there are null element in the array
10586  // the array needs to be trimmed or compacted
10587  goto finish;
10588  }
10589  // cg_c bug, can't use comma operator, extra code
10590  if (e->type == ARRAY) {
10591  m = sToString(e);
10592  }
10593  // cg_c bug, can't use comma operator
10594  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
10595  if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) {
10596  first = middle + 1;
10597  }
10598  else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) {
10599  r = middle;
10600  free(m);
10601  goto finish;
10602  }
10603  else {
10604  last = middle -1;
10605  }
10606  if (e->type == ARRAY) {
10607  free(m);
10608  }
10609  }
10610  finish:
10611  free(s);
10612  return(r);
10613 }
10614 
10615 internal ssize_t icBinarySearchCArraycSmallArray(smallArrayt *self, const char **array) {
10616  ssize_t first = 0, middle, last;;
10617 
10618  if (!lenSmallArray(self) || !array) {
10619  return(-1);
10620  }
10621 
10622  char *s = toStringListCSGF(array);
10623  smallt *e = NULL;
10624  char *m = NULL;
10625 
10626  ssize_t r = -1;
10627  last = (ssize_t)lenSmallArray(self) - 1;
10628  while (first <= last) {
10629  middle = (first+last)/2;
10630  e = sArrayGetTiny(self->a, (uint32_t)middle);
10631  if (!e) {
10632  // there are null element in the array
10633  // the array needs to be trimmed or compacted
10634  goto finish;
10635  }
10636  // cg_c bug, can't use comma operator, extra code
10637  if (e->type == ARRAY) {
10638  m = sToString(e);
10639  }
10640  // cg_c bug, can't use comma operator
10641  /* if e->type < ARRAY || ((e->type = ARRAY) && strcmp((m=sToString(e),m), s) < 0) */
10642  if (e->type < ARRAY || ((e->type == ARRAY) && strcasecmp(m, s) < 0)) {
10643  first = middle + 1;
10644  }
10645  else if ((e->type == ARRAY) && strcasecmp(m, s) == 0) {
10646  r = middle;
10647  free(m);
10648  goto finish;
10649  }
10650  else {
10651  last = middle -1;
10652  }
10653  if (e->type == ARRAY) {
10654  free(m);
10655  }
10656  }
10657  finish:
10658  free(s);
10659  return(r);
10660 }
10661 
10662 internal ssize_t icBinarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string) {
10663 
10664  if (!lenSmallArray(self) || !string) {
10665  return(-1);
10666  }
10667 
10668  if (checkObjectTypes && !isOSmallJson(string)) {
10669  return(-1);
10670  }
10671 
10672  const char *type = getTopTypeO(string);
10673 
10674  if (!type) {
10675  // smallJson is empty
10676  return(-1);
10677  }
10678 
10679  baset *O = NULL;
10680  ssize_t r = -1;
10681  if (eqS(type, "undefined")) {
10682  // it doesn't make sense to search for undefined
10683  // the array has to be sorted
10684  // so undefined is always at postion 0
10685  return(-1);
10686  }
10687  else if (eqS(type, "bool")) {
10688  O = getTopO(string);
10689  r = binarySearchSmallBoolSmallArray(self, (smallBoolt*)O);
10690  finishO(O);
10691  }
10692  else if (eqS(type, "double")) {
10693  O = getTopO(string);
10694  r = binarySearchSmallDoubleSmallArray(self, (smallDoublet*)O);
10695  finishO(O);
10696  }
10697  else if (eqS(type, "int")) {
10698  O = getTopO(string);
10699  r = binarySearchSmallIntSmallArray(self, (smallIntt*)O);
10700  finishO(O);
10701  }
10702  else if (eqS(type, "string")) {
10703  O = getTopO(string);
10704  r = icBinarySearchSmallStringSmallArray(self, (smallStringt*)O);
10705  finishO(O);
10706  }
10707  else if (eqS(type, "dict")) {
10708  O = getTopO(string);
10709  r = icBinarySearchDictSmallArray(self, (smallDictt*)O);
10710  finishO(O);
10711  }
10712  else if (eqS(type, "array")) {
10713  O = getTopO(string);
10714  r = icBinarySearchArraySmallArray(self, (smallArrayt*)O);
10715  finishO(O);
10716  }
10717  return(r);
10718 }
10719 
10720 internal ssize_t icBinarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string) {
10721  ssize_t first = 0, middle, last;;
10722 
10723  if (!lenSmallArray(self) || !string || !string->data) {
10724  return(-1);
10725  }
10726 
10727  if (checkObjectTypes && !isOSmallString(string)) {
10728  return(-1);
10729  }
10730 
10731  char *s = sStringGetTiny(string->data);
10732  smallt *e = NULL;
10733 
10734  last = (ssize_t)lenSmallArray(self) - 1;
10735  while (first <= last) {
10736  middle = (first+last)/2;
10737  e = sArrayGetTiny(self->a, (uint32_t)middle);
10738  if (!e) {
10739  // there are null element in the array
10740  // the array needs to be trimmed or compacted
10741  return(-1);
10742  }
10743  char *m = sStringGetTiny((sStringt*)(e));
10744  if (e->type < STRING || ((e->type == STRING) && (strcasecmp(m, s) < 0))) {
10745  first = middle + 1;
10746  }
10747  else if ((e->type == STRING) && (strcasecmp(m, s) == 0)) {
10748  return(middle);
10749  }
10750  else {
10751  last = middle -1;
10752  }
10753  }
10754  return(-1);
10755 }
10756 
10757 
10758 
10759 
10760 
10761 internal smallArrayt* icUniqSmallArray(smallArrayt *self) {
10762 
10763  // sanity checks
10764  if (!lenSmallArray(self)) {
10765  return(NULL);
10766  }
10767 
10768  if (lenSmallArray(self) == 1) {
10769  return(self);
10770  }
10771 
10772  createAllocateSmallArray(r);
10773  if (!r) {
10774  return(NULL);
10775  }
10776  createAllocateSmallArray(a);
10777  if (!a) {
10778  terminateO(r);
10779  return(NULL);
10780  }
10781  createAllocateSmallDict(d);
10782  if (!d) {
10783  terminateO(r);
10784  terminateO(a);
10785  return(NULL);
10786  }
10787  createAllocateSmallBytes(B);
10788  if (!B) {
10789  terminateO(r);
10790  terminateO(a);
10791  terminateO(B);
10792  return(NULL);
10793  }
10794 
10795  // push element to new list if it is not already in new list
10796  bool pushE = false;
10797  bool foundUndefined = false;
10798  forEachSArray(self->a, e) {
10799  if (e) {
10800  switch (e->type) {
10801  case UNDEFINED:
10802  if (!foundUndefined) {
10803  pushE = true;
10804  foundUndefined = true;
10805  }
10806  else {
10807  free(e);
10808  }
10809  break;
10810  case BOOL:
10811  if (r->f->indexOfBool(r, ((sBoolt*)e)->value) == -1) {
10812  pushE = true;
10813  }
10814  else {
10815  free(e);
10816  }
10817  break;
10818  // TODO case CONTAINER:
10819  case DICT:
10820  d->d = (sDictt*)e;
10821  if (r->f->icIndexOfDict(r, d) == -1) {
10822  pushE = true;
10823  }
10824  else {
10825  freeO(d);
10826  }
10827  break;
10828  case DOUBLE:
10829  if (r->f->indexOfDouble(r, ((sDoublet*)e)->value) == -1) {
10830  pushE = true;
10831  }
10832  else {
10833  free(e);
10834  }
10835  break;
10836  case INT:
10837  if (r->f->indexOfInt(r, ((sIntt*)e)->value) == -1) {
10838  pushE = true;
10839  }
10840  else {
10841  free(e);
10842  }
10843  break;
10844  case STRING:
10845  if (r->f->icIndexOfS(r, sStringGetTiny((sStringt*)e)) == -1) {
10846  pushE = true;
10847  }
10848  else {
10849  free(e);
10850  }
10851  break;
10852  case ARRAY:
10853  a->a = (sArrayt*)e;
10854  if (r->f->icIndexOfArray(r, a) == -1) {
10855  pushE = true;
10856  }
10857  else {
10858  freeO(a);
10859  }
10860  break;
10861  case BYTES:
10862  B->B = (sBytest*)e;
10863  if (r->f->indexOfSmallBytes(r, B) == -1) {
10864  pushE = true;
10865  }
10866  else {
10867  freeO(B);
10868  }
10869  break;
10870  default:
10871  logC("Unsupported object type!");
10872  }
10873  }
10874  if (pushE) {
10875  sArrayPushTiny(&(r->a), e);
10876  pushE = false;
10877  }
10878  }
10879 
10880  finishManyG(a, d, B);
10881 
10882  free(self->a);
10883  self->a = r->a;
10884  finishO(r);
10885  return(self);
10886 }
10887 
10888 
10889 internal smallArrayt* compactSmallArray(smallArrayt *self) {
10890 
10891  // sanity checks
10892  if (!lenSmallArray(self)) {
10893  return(NULL);
10894  }
10895 
10896  createAllocateSmallArray(r);
10897  if (!r) {
10898  return(NULL);
10899  }
10900 
10901  char *trim = NULL;
10902 
10903  // keep non empty elements
10904  forEachSArray(self->a, e) {
10905  if (e) {
10906  switch (e->type) {
10907  case UNDEFINED:
10908  free(e);
10909  break;
10910  case BOOL:
10911  sArrayPushTiny(&(r->a), e);
10912  break;
10913  case CONTAINER:
10914  sArrayPushTiny(&(r->a), e);
10915  break;
10916  case DICT:
10917  if (((sDictt*)e)->count > 0) {
10918  sArrayPushTiny(&(r->a), e);
10919  }
10920  else {
10921  sFree(e);
10922  }
10923  break;
10924  case DOUBLE:
10925  sArrayPushTiny(&(r->a), e);
10926  break;
10927  case INT:
10928  sArrayPushTiny(&(r->a), e);
10929  break;
10930  case STRING:
10931  trim = trimS(sStringGetTiny((sStringt*)e));
10932  if (*trim != 0) {
10933  sArrayPushTiny(&(r->a), e);
10934  }
10935  else {
10936  free(e);
10937  }
10938  free(trim);
10939  break;
10940  case ARRAY:
10941  if (((sArrayt*)e)->count > 0) {
10942  sArrayPushTiny(&(r->a), e);
10943  }
10944  else {
10945  sFree(e);
10946  }
10947  break;
10948  case BYTES:
10949  if (((sBytest*)e)->count > 0) {
10950  sArrayPushTiny(&(r->a), e);
10951  }
10952  else {
10953  sFree(e);
10954  }
10955  break;
10956  default:
10957  logC("Unsupported object type!");
10958  }
10959  }
10960  }
10961 
10962  free(self->a);
10963  if ((r->a)) {
10964  self->a = r->a;
10965  }
10966  else {
10967  // r->a is null and has no elements, allocate an empty sArray
10968  // to make setP work correctly after a call to compact.
10969  // For example:
10970  // smallArrayt *a = getG(dict, rtSmallArrayt, "key");
10971  // compactG(a);
10972  // setNFreePG(dict, "key", a);
10973  // if self->a is null then setNFreePG returns an error and the "key" array pointer
10974  // is not updated causing memory errors
10975  self->a = allocSArray();;
10976  }
10977  finishO(r);
10978  return(self);
10979 }
10980 
10981 
10982 internal smallArrayt* emptySmallArray(smallArrayt *self) {
10983 
10984  freeSmallArray(self);
10985  return(self);
10986 }
10987 
10988 internal bool isEmptySmallArray(smallArrayt *self) {
10989  size_t len;
10990 
10991  len = lenSmallArray(self);
10992 
10993  if (!len) {
10994  return(true);
10995  }
10996 
10997  for (size_t i=0; i < len; i++) {
10998  smallt *o = sArrayGetTiny(self->a, (uint32_t)i);
10999  if (o) {
11000  return(false);
11001  }
11002  }
11003 
11004  return(true);
11005 }
11006 
11007 internal bool isBlankSmallArray(smallArrayt *self) {
11008 
11009  if (!lenSmallArray(self)) {
11010  return(true);
11011  }
11012 
11013  forEachSArray(self->a, e) {
11014  if (e) {
11015  switch (e->type) {
11016  // skip undefined - case UNDEFINED:
11017  case BOOL:
11018  return(false);
11019  case CONTAINER:
11020  return(false);
11021  case DICT:
11022  if (((sDictt*)e)->count > 0) {
11023  return(false);
11024  }
11025  break;
11026  case DOUBLE:
11027  return(false);
11028  case INT:
11029  return(false);
11030  case STRING:
11031  if (!isBlankS(sStringGetTiny((sStringt*)e))) {
11032  return(false);
11033  }
11034  break;
11035  case ARRAY:
11036  if (((sArrayt*)e)->count > 0) {
11037  return(false);
11038  }
11039  break;
11040  case BYTES:
11041  if (((sBytest*)e)->count > 0) {
11042  return(false);
11043  }
11044  break;
11045  default:
11046  logC("Unsupported object type!");
11047  }
11048  }
11049  }
11050  return(true);
11051 }
11052 
11053 internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem) {
11054 
11055  // sanity checks
11056  if (!lenSmallArray(self)) {
11057  return;
11058  }
11059 
11060  forEachSArray(self->a, e) {
11061  if (not e) {
11062  continue;
11063  }
11064  baset *E = toBaset(e);
11065  if (!funcElem(closure, E)) {
11066  if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) {
11067  break;
11068  }
11069  finishO(E);
11070  break;
11071  }
11072  if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) {
11073  continue;
11074  }
11075  finishO(E);
11076  }
11077  return;
11078 }
11079 
11080 internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem) {
11081 
11082  // sanity checks
11083  if (!lenSmallArray(self)) {
11084  return;
11085  }
11086 
11087  enumerateSArray(self->a, e, i) {
11088  if (not e) {
11089  continue;
11090  }
11091  baset *E = toBaset(e);
11092  if (!funcElem(closure, i, E)) {
11093  if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) {
11094  break;
11095  }
11096  finishO(E);
11097  break;
11098  }
11099  if (e->type == CONTAINER && ((sContainert*)e)->dataType == SH_DT_BASET) {
11100  continue;
11101  }
11102  finishO(E);
11103  }
11104  return;
11105 }
11106 
11107 internal baset* iterStartSmallArray(smallArrayt *self) {
11108 
11109  // reset iterIndex to a known value
11110  self->iterIndex = -1;
11111  if (isEmptySmallArray(self)) {
11112  // no iteration on empty arrays
11113  return(NULL);
11114  }
11115 
11116  // get first element
11117  // find first non NULL element, deleted element can be at index 0
11118  range(i, self->a->count)
11119  if (sArrayGetTiny(self->a, (uint32_t)i)) {
11120  self->iterIndex = (ssize_t)i;
11121  break;
11122  }
11123  self->iterStep = 1;
11124  if (self->iterElementDataType != SH_DT_BASET) {
11125  // free already created base object
11126  finishO(self->iterElement);
11127  }
11128  smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex);
11129  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
11130  self->iterElementDataType = SH_DT_BASET;
11131  }
11132  else {
11133  self->iterElementDataType = SH_DT_UNKNOWN;
11134  }
11135  self->iterElement = toBaset(o);
11136  return(self->iterElement);
11137 }
11138 
11139 internal baset* iterStartLastSmallArray(smallArrayt *self) {
11140 
11141  // reset iterIndex to a known value
11142  self->iterIndex = -1;
11143  if (isEmptySmallArray(self)) {
11144  // no iteration on empty arrays
11145  return(NULL);
11146  }
11147 
11148  // get first element
11149  // find first non NULL element, deleted element can be at index 0
11150  rangeDown(i, self->a->count)
11151  if (sArrayGetTiny(self->a, (uint32_t)i)) {
11152  self->iterIndex = i;
11153  break;
11154  }
11155  self->iterStep = -1;
11156  if (self->iterElementDataType != SH_DT_BASET) {
11157  // free already created base object
11158  finishO(self->iterElement);
11159  }
11160  smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex);
11161  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
11162  self->iterElementDataType = SH_DT_BASET;
11163  }
11164  else {
11165  self->iterElementDataType = SH_DT_UNKNOWN;
11166  }
11167  self->iterElement = toBaset(o);
11168  return(self->iterElement);
11169 }
11170 
11171 internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index) {
11172 
11173  // reset iterIndex to a known value
11174  self->iterIndex = -1;
11175  if (isEmptySmallArray(self)) {
11176  // no iteration on empty arrays
11177  return(NULL);
11178  }
11179 
11180  if (index >= (int64_t)lenSmallArray(self)) {
11181  return(NULL);
11182  }
11183  if (index < -(int64_t)lenSmallArray(self)) {
11184  return(NULL);
11185  }
11186  if (index < 0) {
11187  index = (int64_t)lenSmallArray(self) + index;
11188  }
11189 
11190  // get first element
11191  // find first non NULL element, deleted element can be at index 0
11192  rangeFrom(i, (size_t)index, self->a->count)
11193  if (sArrayGetTiny(self->a, (uint32_t)i)) {
11194  self->iterIndex = (ssize_t)i;
11195  break;
11196  }
11197  if (self->iterIndex == -1) {
11198  // no element was found in the dictionary
11199  return(NULL);
11200  }
11201  self->iterStep = 1;
11202  if (self->iterElementDataType != SH_DT_BASET) {
11203  // free already created base object
11204  finishO(self->iterElement);
11205  }
11206  smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex);
11207  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
11208  self->iterElementDataType = SH_DT_BASET;
11209  }
11210  else {
11211  self->iterElementDataType = SH_DT_UNKNOWN;
11212  }
11213  self->iterElement = toBaset(o);
11214  return(self->iterElement);
11215 }
11216 
11217 internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step) {
11218 
11219  // reset iterIndex to a known value
11220  self->iterIndex = -1;
11221  if (isEmptySmallArray(self)) {
11222  // no iteration on empty arrays
11223  return(NULL);
11224  }
11225 
11226  if (!step) {
11227  // step 0 is invalid because it causes an infinite loop
11228  return(NULL);
11229  }
11230 
11231  if (index >= (int64_t)lenSmallArray(self)) {
11232  return(NULL);
11233  }
11234  if (index < -(int64_t)lenSmallArray(self)) {
11235  return(NULL);
11236  }
11237  if (index < 0) {
11238  index = (int64_t)lenSmallArray(self) + index;
11239  }
11240 
11241  // get first element
11242  // find first non NULL element, deleted element can be at index 0
11243  rangeFromStep(i, (size_t)index, self->a->count, step)
11244  if (sArrayGetTiny(self->a, (uint32_t)i)) {
11245  self->iterIndex = (ssize_t)i;
11246  break;
11247  }
11248  if (self->iterIndex == -1) {
11249  // no element was found in the dictionary
11250  return(NULL);
11251  }
11252  self->iterStep = step;
11253  if (self->iterElementDataType != SH_DT_BASET) {
11254  // free already created base object
11255  finishO(self->iterElement);
11256  }
11257  smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex);
11258  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
11259  self->iterElementDataType = SH_DT_BASET;
11260  }
11261  else {
11262  self->iterElementDataType = SH_DT_UNKNOWN;
11263  }
11264  self->iterElement = toBaset(o);
11265  return(self->iterElement);
11266 }
11267 
11268 internal baset* iterNextSmallArray(smallArrayt *self) {
11269 
11270  if (self->iterIndex == -1) {
11271  // the iteration hasn't started
11272  return(NULL);
11273  }
11274  // free already created base object
11275  if (self->iterElementDataType != SH_DT_BASET) {
11276  finishO(self->iterElement);
11277  }
11278  else {
11279  self->iterElement = NULL;
11280  }
11281  // get next element until we get a valid item or the end is reached
11282  while (!self->iterElement) {
11283  // get next element
11284  self->iterIndex += self->iterStep;
11285  if ((self->iterIndex >= (ssize_t)lenSmallArray(self) || self->iterIndex < 0)) {
11286  // the index is outside the array, the iteration is finished
11287  self->iterIndex = -1;
11288  return(NULL);
11289  }
11290  smallt *o = sArrayGetTiny(self->a, (uint32_t)self->iterIndex);
11291  if (!o) {
11292  continue;
11293  }
11294  if ((o->type == CONTAINER) && (((sContainert*)o)->dataType == SH_DT_BASET)) {
11295  self->iterElementDataType = SH_DT_BASET;
11296  }
11297  else {
11298  self->iterElementDataType = SH_DT_UNKNOWN;
11299  }
11300  self->iterElement = toBaset(o);
11301  }
11302  return(self->iterElement);
11303 }
11304 
11305 internal baset* iterElementSmallArray(smallArrayt *self) {
11306 
11307  return(self->iterElement);
11308 }
11309 
11310 internal ssize_t iterIndexSmallArray(smallArrayt *self) {
11311 
11312  return(self->iterIndex);
11313 }
11314 
11315 internal int64_t iterStepSmallArray(smallArrayt *self) {
11316 
11317  return(self->iterStep);
11318 }
11319 
11320 internal smallStringt* joinSmallArray(smallArrayt *self, const char* delim) {
11321  smallStringt *r = NULL;
11322 
11323  // sanity checks
11324  if (!lenSmallArray(self) || !delim) {
11325  return(NULL);
11326  }
11327 
11328  char *s;
11329 
11330  forEachSArray(self->a, e) {
11331  if (e) {
11332  switch (e->type) {
11333  case STRING:
11334  if (!r) {
11335  r = allocSmallString(sStringGetTiny((sStringt*)e));
11336  }
11337  else {
11338  r->f->appendS(r, delim);
11339  r->f->appendS(r, sStringGetTiny((sStringt*)e));
11340  }
11341  break;
11342  default:
11343  s = sToString(e);
11344  if (!r) {
11345  r = allocSmallString(s);
11346  }
11347  else {
11348  r->f->appendS(r, delim);
11349  r->f->appendS(r, s);
11350  }
11351  free(s);
11352  }
11353  }
11354  }
11355  return(r);
11356 }
11357 
11358 internal smallStringt* joinCharSmallArray(smallArrayt *self, char c) {
11359 
11360  charToS(s, c);
11361  return(joinSmallArray(self, s));
11362 }
11363 
11364 internal smallStringt* joinSmallJsonSmallArray(smallArrayt *self, smallJsont* delim) {
11365 
11366  if (!delim) {
11367  return(NULL);
11368  }
11369 
11370  if (checkObjectTypes && !isOSmallJson(delim)) {
11371  return(NULL);
11372  }
11373 
11374  const char *type = getTopTypeO(delim);
11375 
11376  if (!eqS(type,"string")) {
11377  return(NULL);
11378  }
11379 
11380  return(joinSmallArray(self, sjGet(delim)));
11381 }
11382 
11383 internal smallStringt* joinSmallStringSmallArray(smallArrayt *self, smallStringt* delim) {
11384 
11385  if (!delim) {
11386  return(NULL);
11387  }
11388  return(joinSmallArray(self, ssGet(delim)));
11389 }
11390 
11391 internal char* joinSSmallArray(smallArrayt *self, const char* delim) {
11392  char *r = NULL;
11393 
11394  // sanity checks
11395  if (!lenSmallArray(self) || !delim) {
11396  return(NULL);
11397  }
11398 
11399  char *s;
11400 
11401  forEachSArray(self->a, e) {
11402  if (e) {
11403  switch (e->type) {
11404  case STRING:
11405  if (!r) {
11406  r = strdup(sStringGetTiny((sStringt*)e));
11407  }
11408  else {
11409  pErrorNULL(iAppendS(&r, delim));
11410  pErrorNULL(iAppendS(&r, sStringGetTiny((sStringt*)e)));
11411  }
11412  break;
11413  default:
11414  s = sToString(e);
11415  if (!s) {
11416  free(r);
11417  return(NULL);
11418  }
11419  if (!r) {
11420  r = strdup(s);
11421  }
11422  else {
11423  pErrorNULL(iAppendS(&r, delim));
11424  pErrorNULL(iAppendS(&r, s));
11425  }
11426  free(s);
11427  }
11428  }
11429  }
11430 
11431  return(r);
11432 }
11433 
11434 internal char* joinCharSSmallArray(smallArrayt *self, char c) {
11435 
11436  charToS(s, c);
11437  return(joinSSmallArray(self, s));
11438 }
11439 
11440 internal char* joinSmallJsonSSmallArray(smallArrayt *self, smallJsont* delim) {
11441 
11442  if (!delim) {
11443  return(NULL);
11444  }
11445 
11446  if (checkObjectTypes && !isOSmallJson(delim)) {
11447  return(NULL);
11448  }
11449 
11450  const char *type = getTopTypeO(delim);
11451 
11452  if (!eqS(type,"string")) {
11453  return(NULL);
11454  }
11455 
11456  return(joinSSmallArray(self, sjGet(delim)));
11457 }
11458 
11459 internal char* joinSmallStringSSmallArray(smallArrayt *self, smallStringt* delim) {
11460 
11461  if (!delim) {
11462  return(NULL);
11463  }
11464  return(joinSSmallArray(self, ssGet(delim)));
11465 }
11466 
11467 internal smallArrayt* zipSmallArray(smallArrayt *self, smallArrayt *array1, smallArrayt *array2) {
11468  size_t len;
11469  size_t count;
11470 
11471  if (!array1 || !array2) {
11472  return(NULL);
11473  }
11474 
11475  if (checkObjectTypes && (!isOSmallArray(array1) || !isOSmallArray(array2))) {
11476  return(NULL);
11477  }
11478 
11479  if (!array1->f->len(array1) || !array2->f->len(array2)) {
11480  return(self);
11481  }
11482 
11483  len = MIN(array1->f->len(array1), array2->f->len(array2));
11484 
11485  count = 0;
11486 
11487  enumerateSmallArray(array1, E1, i) {
11488  createAllocateSmallArray(a);
11489  if (!a) {
11490  finishO(E1);
11491  return(NULL);
11492  }
11493  pushNFreeO(a, E1);
11494  pushNFreeO(a, getO(array2, (int64_t)i));
11495  pushNFreeArraySmallArray(self, a);
11496  count++;
11497  if (count == len) {
11498  break;
11499  }
11500  }
11501 
11502  return(self);
11503 }
11504 
11505 internal smallArrayt* zipSmallJsonSmallArray(smallArrayt *self, smallArrayt *array1, smallJsont *array2) {
11506 
11507  if (!array1 || !array2) {
11508  return(NULL);
11509  }
11510 
11511  if (checkObjectTypes && !isOSmallArray(array1)) {
11512  return(NULL);
11513  }
11514 
11515  if (checkObjectTypes && !isOSmallJson(array2)) {
11516  return(NULL);
11517  }
11518 
11519  const char *type = getTopTypeO(array2);
11520 
11521  if (!eqS(type,"array")) {
11522  return(NULL);
11523  }
11524 
11525  createSmallArray(a);
11526  if (!a.f) {
11527  return(NULL);
11528  }
11529  setsoO(&a, (sArrayt*)getsoO(array2));
11530  return(zipSmallArray(self, array1, &a));
11531 }
11532 
11533 internal smallArrayt* zipSmallJsonSmallArraySmallArray(smallArrayt *self, smallJsont *array1, smallArrayt *array2) {
11534 
11535  if (!array1 || !array2) {
11536  return(NULL);
11537  }
11538 
11539  if (checkObjectTypes && !isOSmallJson(array1)) {
11540  return(NULL);
11541  }
11542 
11543  if (checkObjectTypes && !isOSmallArray(array2)) {
11544  return(NULL);
11545  }
11546 
11547  const char *type = getTopTypeO(array1);
11548 
11549  if (!eqS(type,"array")) {
11550  return(NULL);
11551  }
11552 
11553  createSmallArray(a);
11554  if (!a.f) {
11555  return(NULL);
11556  }
11557  setsoO(&a, (sArrayt*)getsoO(array1));
11558  return(zipSmallArray(self, &a, array2));
11559 }
11560 
11561 internal smallArrayt* zipSmallJsonSmallJsonSmallArray(smallArrayt *self, smallJsont *array1, smallJsont *array2) {
11562 
11563  if (!array1 || !array2) {
11564  return(NULL);
11565  }
11566 
11567  if (checkObjectTypes && !isOSmallJson(array1)) {
11568  return(NULL);
11569  }
11570 
11571  if (checkObjectTypes && !isOSmallJson(array2)) {
11572  return(NULL);
11573  }
11574 
11575  const char *type = getTopTypeO(array1);
11576 
11577  if (!eqS(type,"array")) {
11578  return(NULL);
11579  }
11580 
11581  type = getTopTypeO(array2);
11582 
11583  if (!eqS(type,"array")) {
11584  return(NULL);
11585  }
11586 
11587  createSmallArray(a);
11588  if (!a.f) {
11589  return(NULL);
11590  }
11591  createSmallArray(b);
11592  if (!b.f) {
11593  return(NULL);
11594  }
11595  setsoO(&a, (sArrayt*)getsoO(array1));
11596  setsoO(&b, (sArrayt*)getsoO(array2));
11597  return(zipSmallArray(self, &a, &b));
11598 }
11599 
11600 internal smallArrayt* zipSmallJsonCharSmallArray(smallArrayt *self, smallJsont *array1, char **array2) {
11601 
11602  if (!array1 || !array2) {
11603  return(NULL);
11604  }
11605 
11606  if (checkObjectTypes && !isOSmallJson(array1)) {
11607  return(NULL);
11608  }
11609 
11610  const char *type = getTopTypeO(array1);
11611 
11612  if (!eqS(type,"array")) {
11613  return(NULL);
11614  }
11615 
11616  createSmallArray(a);
11617  if (!a.f) {
11618  return(NULL);
11619  }
11620  setsoO(&a, (sArrayt*)getsoO(array1));
11621  return(zipCharSmallArray(self, &a, array2));
11622 }
11623 
11624 internal smallArrayt* zipSmallJsonCCharSmallArray(smallArrayt *self, smallJsont *array1, const char **array2) {
11625 
11626  if (!array1 || !array2) {
11627  return(NULL);
11628  }
11629 
11630  if (checkObjectTypes && !isOSmallJson(array1)) {
11631  return(NULL);
11632  }
11633 
11634  const char *type = getTopTypeO(array1);
11635 
11636  if (!eqS(type,"array")) {
11637  return(NULL);
11638  }
11639 
11640  createSmallArray(a);
11641  if (!a.f) {
11642  return(NULL);
11643  }
11644  setsoO(&a, (sArrayt*)getsoO(array1));
11645  return(zipCCharSmallArray(self, &a, array2));
11646 }
11647 
11648 internal smallArrayt* zipArraySmallArray(smallArrayt *self, char** array1, smallArrayt *array2) {
11649  size_t len;
11650  size_t count;
11651 
11652  if (!array1 || !array2) {
11653  return(NULL);
11654  }
11655 
11656  if (checkObjectTypes && !isOSmallArray(array2)) {
11657  return(NULL);
11658  }
11659 
11660  if (!listLengthS(array1) || !array2->f->len(array2)) {
11661  return(self);
11662  }
11663 
11664  len = MIN(listLengthS(array1), array2->f->len(array2));;
11665 
11666  count = 0;
11667 
11668  enumerateS(array1, E1, i) {
11669  createAllocateSmallArray(a);
11670  if (!a) {
11671  return(NULL);
11672  }
11673  a->f->pushNFreeS(a, E1);
11674  pushNFreeO(a, getO(array2, (int64_t)i));
11675  pushNFreeArraySmallArray(self, a);
11676  count++;
11677  if (count == len) {
11678  break;
11679  }
11680  }
11681 
11682  return(self);
11683 }
11684 
11685 internal smallArrayt* zipCArraySmallArray(smallArrayt *self, const char** array1, smallArrayt *array2) {
11686  size_t len;
11687  size_t count;
11688 
11689  if (!array1 || !array2) {
11690  return(NULL);
11691  }
11692 
11693  if (checkObjectTypes && !isOSmallArray(array2)) {
11694  return(NULL);
11695  }
11696 
11697  if (!listLengthCS(array1) || !array2->f->len(array2)) {
11698  return(self);
11699  }
11700 
11701  len = MIN(listLengthCS(array1), array2->f->len(array2));;
11702 
11703  count = 0;
11704 
11705  enumerateCS(array1, E1, i) {
11706  createAllocateSmallArray(a);
11707  if (!a) {
11708  return(NULL);
11709  }
11710  a->f->pushS(a, E1);
11711  pushNFreeO(a, getO(array2, (int64_t)i));
11712  pushNFreeArraySmallArray(self, a);
11713  count++;
11714  if (count == len) {
11715  break;
11716  }
11717  }
11718 
11719  return(self);
11720 }
11721 
11722 internal smallArrayt* zipArraySmallJsonSmallArray(smallArrayt *self, char** array1, smallJsont *array2) {
11723 
11724  if (!array1 || !array2) {
11725  return(NULL);
11726  }
11727 
11728  if (checkObjectTypes && !isOSmallJson(array2)) {
11729  return(NULL);
11730  }
11731 
11732  const char *type = getTopTypeO(array2);
11733 
11734  if (!eqS(type,"array")) {
11735  return(NULL);
11736  }
11737 
11738  createSmallArray(a);
11739  if (!a.f) {
11740  return(NULL);
11741  }
11742  setsoO(&a, (sArrayt*)getsoO(array2));
11743  return(zipArraySmallArray(self, array1, &a));
11744 }
11745 
11746 internal smallArrayt* zipCArraySmallJsonSmallArray(smallArrayt *self, const char** array1, smallJsont *array2) {
11747 
11748  if (!array1 || !array2) {
11749  return(NULL);
11750  }
11751 
11752  if (checkObjectTypes && !isOSmallJson(array2)) {
11753  return(NULL);
11754  }
11755 
11756  const char *type = getTopTypeO(array2);
11757 
11758  if (!eqS(type,"array")) {
11759  return(NULL);
11760  }
11761 
11762  createSmallArray(a);
11763  if (!a.f) {
11764  return(NULL);
11765  }
11766  setsoO(&a, (sArrayt*)getsoO(array2));
11767  return(zipCArraySmallArray(self, array1, &a));
11768 }
11769 
11770 internal smallArrayt* zipCharSmallArray(smallArrayt *self, smallArrayt *array1, char** array2) {
11771  size_t len;
11772  size_t count;
11773 
11774  if (!array1 || !array2) {
11775  return(NULL);
11776  }
11777 
11778  if (checkObjectTypes && !isOSmallArray(array1)) {
11779  return(NULL);
11780  }
11781 
11782  if (!array1->f->len(array1) || !listLengthS(array2)) {
11783  return(self);
11784  }
11785 
11786  len = MIN(array1->f->len(array1), listLengthS(array2));;
11787 
11788  count = 0;
11789 
11790  enumerateSmallArray(array1, E1, i) {
11791  createAllocateSmallArray(a);
11792  if (!a) {
11793  finishO(E1);
11794  return(NULL);
11795  }
11796  pushNFreeO(a, E1);
11797  a->f->pushNFreeS(a, array2[i]);
11798  pushNFreeArraySmallArray(self, a);
11799  count++;
11800  if (count == len) {
11801  break;
11802  }
11803  }
11804 
11805  return(self);
11806 }
11807 
11808 internal smallArrayt* zipCCharSmallArray(smallArrayt *self, smallArrayt *array1, const char** array2) {
11809  size_t len;
11810  size_t count;
11811 
11812  if (!array1 || !array2) {
11813  return(NULL);
11814  }
11815 
11816  if (checkObjectTypes && !isOSmallArray(array1)) {
11817  return(NULL);
11818  }
11819 
11820  if (!array1->f->len(array1) || !listLengthCS(array2)) {
11821  return(self);
11822  }
11823 
11824  len = MIN(array1->f->len(array1), listLengthCS(array2));;
11825 
11826  count = 0;
11827 
11828  enumerateSmallArray(array1, E1, i) {
11829  createAllocateSmallArray(a);
11830  if (!a) {
11831  finishO(E1);
11832  return(NULL);
11833  }
11834  pushNFreeO(a, E1);
11835  a->f->pushS(a, array2[i]);
11836  pushNFreeArraySmallArray(self, a);
11837  count++;
11838  if (count == len) {
11839  break;
11840  }
11841  }
11842 
11843  return(self);
11844 }
11845 
11846 internal smallArrayt* zipArrayCharSmallArray(smallArrayt *self, char** array1, char** array2) {
11847  size_t len;
11848  size_t count;
11849 
11850  if (!array1 || !array2) {
11851  return(NULL);
11852  }
11853 
11854  if (!listLengthS(array1) || !listLengthS(array2)) {
11855  return(self);
11856  }
11857 
11858  len = MIN(listLengthS(array1), listLengthS(array2));;
11859 
11860  count = 0;
11861 
11862  enumerateS(array1, E1, i) {
11863  createAllocateSmallArray(a);
11864  if (!a) {
11865  return(NULL);
11866  }
11867  a->f->pushNFreeS(a, E1);
11868  a->f->pushNFreeS(a, array2[i]);
11869  pushNFreeArraySmallArray(self, a);
11870  count++;
11871  if (count == len) {
11872  break;
11873  }
11874  }
11875 
11876  return(self);
11877 }
11878 
11879 internal smallArrayt* zipCArrayCharSmallArray(smallArrayt *self, const char** array1, char** array2) {
11880  size_t len;
11881  size_t count;
11882 
11883  if (!array1 || !array2) {
11884  return(NULL);
11885  }
11886 
11887  if (!listLengthCS(array1) || !listLengthS(array2)) {
11888  return(self);
11889  }
11890 
11891  len = MIN(listLengthCS(array1), listLengthS(array2));;
11892 
11893  count = 0;
11894 
11895  enumerateCS(array1, E1, i) {
11896  createAllocateSmallArray(a);
11897  if (!a) {
11898  return(NULL);
11899  }
11900  a->f->pushS(a, E1);
11901  a->f->pushNFreeS(a, array2[i]);
11902  pushNFreeArraySmallArray(self, a);
11903  count++;
11904  if (count == len) {
11905  break;
11906  }
11907  }
11908 
11909  return(self);
11910 }
11911 
11912 internal smallArrayt* zipArrayCCharSmallArray(smallArrayt *self, char** array1, const char** array2) {
11913  size_t len;
11914  size_t count;
11915 
11916  if (!array1 || !array2) {
11917  return(NULL);
11918  }
11919 
11920  if (!listLengthS(array1) || !listLengthCS(array2)) {
11921  return(self);
11922  }
11923 
11924  len = MIN(listLengthS(array1), listLengthCS(array2));;
11925 
11926  count = 0;
11927 
11928  enumerateS(array1, E1, i) {
11929  createAllocateSmallArray(a);
11930  if (!a) {
11931  return(NULL);
11932  }
11933  a->f->pushNFreeS(a, E1);
11934  a->f->pushS(a, array2[i]);
11935  pushNFreeArraySmallArray(self, a);
11936  count++;
11937  if (count == len) {
11938  break;
11939  }
11940  }
11941 
11942  return(self);
11943 }
11944 
11945 internal smallArrayt* zipCArrayCCharSmallArray(smallArrayt *self, const char** array1, const char** array2) {
11946  size_t len;
11947  size_t count;
11948 
11949  if (!array1 || !array2) {
11950  return(NULL);
11951  }
11952 
11953  if (!listLengthCS(array1) || !listLengthCS(array2)) {
11954  return(self);
11955  }
11956 
11957  len = MIN(listLengthCS(array1), listLengthCS(array2));;
11958 
11959  count = 0;
11960 
11961  enumerateCS(array1, E1, i) {
11962  createAllocateSmallArray(a);
11963  if (!a) {
11964  return(NULL);
11965  }
11966  a->f->pushS(a, E1);
11967  a->f->pushS(a, array2[i]);
11968  pushNFreeArraySmallArray(self, a);
11969  count++;
11970  if (count == len) {
11971  break;
11972  }
11973  }
11974 
11975  return(self);
11976 }
11977 
11978 internal void logSmallArray(smallArrayt *self) {
11979 
11980  if (!lenSmallArray(self)) {
11981  return;
11982  }
11983 
11984  forEachSArray(self->a, e) {
11985  if (e) {
11986  char *s = sToString(e);
11987  if (s) {
11988  puts(s);
11989  }
11990  else {
11991  puts("(null)");
11992  }
11993  free(s);
11994  }
11995  }
11996  return;
11997 }
11998 
11999 internal smallArrayt* readTextSmallArray(smallArrayt *self, const char *filePath) {
12000  FILE *fp = NULL;
12001  size_t len;
12002  char* line = NULL;
12003  ssize_t read;
12004 
12005  // sanity checks
12006  if (!filePath || isBlankS(filePath)) {
12007  return(NULL);
12008  }
12009  fp = fopen(filePath, "r");
12010  if (!fp) {
12011  pFuncError
12012  shEPrintfS("The path was: \"%s\"\n", filePath);
12013  return(NULL);
12014  }
12015 
12016  // read all lines
12017  read = getline(&line, &len, fp);
12018  while (read != -1) {
12019  {
12020  char* pos = NULL;
12021  pos = strchr(line, '\n');
12022  if (pos != NULL)
12023  *pos = '\0';
12024  }
12025  pushSSmallArray(self, line);
12026  read = getline(&line, &len, fp);
12027  }
12028  fclose(fp);
12029  free(line);
12030  return(self);
12031 }
12032 
12033 internal smallArrayt* readTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath) {
12034 
12035  if (!filePath) {
12036  return(NULL);
12037  }
12038 
12039  if (checkObjectTypes && !isOSmallJson(filePath)) {
12040  return(NULL);
12041  }
12042 
12043  const char *type = getTopTypeO(filePath);
12044 
12045  if (!eqS(type,"string")) {
12046  return(NULL);
12047  }
12048 
12049  return(readTextSmallArray(self, getTopSO(filePath)));
12050 }
12051 
12052 internal smallArrayt* readTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) {
12053 
12054  if (!filePath) {
12055  return(NULL);
12056  }
12057 
12058  if (checkObjectTypes && !isOSmallString(filePath)) {
12059  return(NULL);
12060  }
12061 
12062  return(readTextSmallArray(self, ssGet(filePath)));
12063 }
12064 
12065 internal smallArrayt* readStreamSmallArray(smallArrayt *self, FILE *fp) {
12066  size_t len;
12067  char* line = NULL;
12068  ssize_t read;
12069 
12070  if (!fp) {
12071  return(NULL);
12072  }
12073 
12074  // read all lines
12075  read = getline(&line, &len, (FILE*)fp);
12076  while (read != -1) {
12077  {
12078  char* pos = NULL;
12079  pos = strchr(line, '\n');
12080  if (pos != NULL)
12081  *pos = '\0';
12082  }
12083  pushSSmallArray(self, line);
12084  read = getline(&line, &len, (FILE*)fp);
12085  }
12086  free(line);
12087  return(self);
12088 }
12089 
12090 internal bool writeTextSmallArray(smallArrayt *self, const char *filePath) {
12091  FILE *fp = NULL;
12092 
12093  // sanity checks
12094  if (!filePath || isBlankS(filePath)) {
12095  return(false);
12096  }
12097 
12098  fp = fopen(filePath, "w");
12099  if (!fp) {
12100  pFuncError
12101  shEPrintfS("The path was: \"%s\"\n", filePath);
12102  return(false);
12103  }
12104  if (!lenSmallArray(self)) {
12105  fclose(fp);
12106  return(false);
12107  }
12108  forEachSArray(self->a, e) {
12109  if (e) {
12110  // add new line
12111  fprintf(fp, "%s\n", sStringGetTiny((sStringt*)e));
12112  }
12113  }
12114  fclose(fp);
12115  return(true);
12116 }
12117 
12118 internal bool writeTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath) {
12119 
12120  if (!filePath) {
12121  return(false);
12122  }
12123 
12124  if (checkObjectTypes && !isOSmallJson(filePath)) {
12125  return(false);
12126  }
12127 
12128  const char *type = getTopTypeO(filePath);
12129 
12130  if (!eqS(type,"string")) {
12131  return(false);
12132  }
12133 
12134  return(writeTextSmallArray(self, getTopSO(filePath)));
12135 }
12136 
12137 internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) {
12138 
12139  if (!filePath) {
12140  return(false);
12141  }
12142 
12143  if (checkObjectTypes && !isOSmallString(filePath)) {
12144  return(false);
12145  }
12146 
12147  return(writeTextSmallArray(self, ssGet(filePath)));
12148 }
12149 
12150 internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp) {
12151 
12152  // sanity checks
12153  if (!fp || !lenSmallArray(self)) {
12154  return(false);
12155  }
12156  forEachSArray(self->a, e) {
12157  if (e) {
12158  // add new line
12159  fprintf((FILE*)fp, "%s\n", sStringGetTiny((sStringt*)e));
12160  }
12161  }
12162  return(true);
12163 }
12164 
12165 internal bool appendTextSmallArray(smallArrayt *self, const char *filePath) {
12166  FILE *fp = NULL;
12167 
12168  // sanity checks
12169  if (!filePath || isBlankS(filePath)) {
12170  return(false);
12171  }
12172 
12173  fp = fopen(filePath, "a");
12174  if (!fp) {
12175  pStrError("writeText error");
12176  return(false);
12177  }
12178  if (!lenSmallArray(self)) {
12179  fclose(fp);
12180  return(false);
12181  }
12182  forEachSArray(self->a, e) {
12183  if (e) {
12184  // add new line
12185  fprintf(fp, "%s\n", sStringGetTiny((sStringt*)e));
12186  }
12187  }
12188  fclose(fp);
12189  return(true);
12190 }
12191 
12192 internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath) {
12193 
12194  if (!filePath) {
12195  return(false);
12196  }
12197 
12198  if (checkObjectTypes && !isOSmallString(filePath)) {
12199  return(false);
12200  }
12201 
12202  return(appendTextSmallArray(self, ssGet(filePath)));
12203 }
12204 
12205 
12206 internal const char* typeStringSmallArray(smallArrayt *self, int64_t index) {
12207 
12208  return(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)]);
12209 }
12210 
12211 internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index) {
12212 
12213  return(allocSmallString(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)]));
12214 }
12215 
12216 internal char typeSmallArray(smallArrayt *self, int64_t index) {
12217  size_t len;
12218 
12219  len = lenSmallArray(self);
12220 
12221  if (!len) {
12222  return(0);
12223  }
12224 
12225  if (index >= (int64_t)len) {
12226  return(0);
12227  }
12228  if (index < -(int64_t)len) {
12229  return(0);
12230  }
12231  if (index < 0) {
12232  index = (int64_t)len + index;
12233  }
12234 
12235  smallt *r = sArrayGetTiny(self->a, (uint32_t)index);
12236  if (!r) {
12237  return(0);
12238  }
12239 
12240  return(r->type);
12241 }
12242 
12243 internal const char** typeStringsSmallArray(smallArrayt *self) {
12244 
12245  return(sArrayTypeStrings(self->a));
12246 }
12247 
12248 internal smallArrayt* typeSmallStringsSmallArray(smallArrayt *self) {
12249 
12250  const char** r = sArrayTypeStrings(self->a);
12251  if (!r) {
12252  return(NULL);
12253  }
12254  createAllocateSmallArray(a);
12255  if (!a) {
12256  return(NULL);
12257  }
12258  fromCArraySmallArray(a, r, 0);
12259  free(r);
12260  return(a);
12261 }
12262 
12263 internal smallBytest* typesSmallArray(smallArrayt *self) {
12264  sBytest *types = NULL;
12265 
12266  types = sArrayTypes(self->a);
12267 
12268  if (!types) {
12269  return(NULL);
12270  }
12271 
12272  createAllocateSmallBytes(r);
12273  if (!r) {
12274  return(NULL);
12275  }
12276  r->B = types;
12277  return(r);
12278 }
12279 
12280 internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type) {
12281 
12282  if (!type) {
12283  return(false);
12284  }
12285 
12286  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], type));
12287 }
12288 
12289 internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index) {
12290 
12291  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "undefined"));
12292 }
12293 
12294 internal bool isEBoolSmallArray(smallArrayt *self, int64_t index) {
12295 
12296  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bool"));
12297 }
12298 
12299 internal bool isEContainerSmallArray(smallArrayt *self, int64_t index) {
12300 
12301  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "container"));
12302 }
12303 
12304 internal bool isEDictSmallArray(smallArrayt *self, int64_t index) {
12305 
12306  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "dict"));
12307 }
12308 
12309 internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index) {
12310 
12311  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "double"));
12312 }
12313 
12314 internal bool isEIntSmallArray(smallArrayt *self, int64_t index) {
12315 
12316  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "int"));
12317 }
12318 
12319 internal bool isEStringSmallArray(smallArrayt *self, int64_t index) {
12320 
12321  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "string"));
12322 }
12323 
12324 internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index) {
12325 
12326  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "faststring"));
12327 }
12328 
12329 internal bool isEArraySmallArray(smallArrayt *self, int64_t index) {
12330 
12331  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "array"));
12332 }
12333 
12334 internal bool isEBytesSmallArray(smallArrayt *self, int64_t index) {
12335 
12336  return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bytes"));
12337 }
12338 
12339 internal bool areAllETypeSmallArray(smallArrayt *self, const char *type) {
12340 
12341  if (!type) {
12342  return(false);
12343  }
12344 
12345  size_t len = lenSmallArray(self);
12346 
12347  if (!len) {
12348  return(false);
12349  }
12350 
12351  bool r = true;
12352  range(i, len) {
12353  if (!eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, (int64_t)i)], type)) {
12354  r = false;
12355  break;
12356  }
12357  }
12358  return(r);
12359 }
12360 
12361 internal bool areAllEUndefinedSmallArray(smallArrayt *self) {
12362 
12363  return(areAllETypeSmallArray(self, "undefined"));
12364 }
12365 
12366 internal bool areAllEBoolSmallArray(smallArrayt *self) {
12367 
12368  return(areAllETypeSmallArray(self, "bool"));
12369 }
12370 
12371 internal bool areAllEContainerSmallArray(smallArrayt *self) {
12372 
12373  return(areAllETypeSmallArray(self, "container"));
12374 }
12375 
12376 internal bool areAllEDictSmallArray(smallArrayt *self) {
12377 
12378  return(areAllETypeSmallArray(self, "dict"));
12379 }
12380 
12381 internal bool areAllEDoubleSmallArray(smallArrayt *self) {
12382 
12383  return(areAllETypeSmallArray(self, "double"));
12384 }
12385 
12386 internal bool areAllEIntSmallArray(smallArrayt *self) {
12387 
12388  return(areAllETypeSmallArray(self, "int"));
12389 }
12390 
12391 internal bool areAllEStringSmallArray(smallArrayt *self) {
12392 
12393  return(areAllETypeSmallArray(self, "string"));
12394 }
12395 
12396 internal bool areAllEFaststringSmallArray(smallArrayt *self) {
12397 
12398  return(areAllETypeSmallArray(self, "faststring"));
12399 }
12400 
12401 internal bool areAllEArraySmallArray(smallArrayt *self) {
12402 
12403  return(areAllETypeSmallArray(self, "array"));
12404 }
12405 
12406 internal bool areAllEBytesSmallArray(smallArrayt *self) {
12407 
12408  return(areAllETypeSmallArray(self, "bytes"));
12409 }
12410 
12411 
12412 
12413 smallArrayt* allocSmallArrayG(smallArrayt *self UNUSED) {
12414 
12415  return(allocSmallArray());
12416 }
12417 
12418 smallArrayt* duplicateSmallArrayG (smallArrayt *self) {
12419 
12420  return(self->f->duplicate(self));
12421 }
12422 
12423 void freeSmallArrayG (smallArrayt *self) {self->f->free(self);}
12424 
12425 smallArrayt* fromArraySmallArrayG (smallArrayt *self, char **array, size_t size) {
12426 
12427  return(self->f->fromArray(self, array, size));
12428 }
12429 
12430 smallArrayt* fromCArraySmallArrayG (smallArrayt *self, const char **array, size_t size) {
12431 
12432  return(self->f->fromCArray(self, array, size));
12433 }
12434 
12435 smallArrayt* setFromSmallArrayG(smallArrayt *self, char **array) {
12436 
12437  return(self->f->fromArray(self, array, 0));
12438 }
12439 
12440 smallArrayt* setFromCSmallArrayG(smallArrayt *self, const char **array) {
12441 
12442  return(self->f->fromCArray(self, array, 0));
12443 }
12444 
12445 smallArrayt* pushSmallArrayG (smallArrayt *self, baset *value) {
12446 
12447  return(self->f->push(self, value));
12448 }
12449 
12450 smallArrayt* pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED) {
12451 
12452  return(self->f->pushUndefined(self));
12453 }
12454 
12455 smallArrayt* pushBoolSmallArrayG (smallArrayt *self, bool value) {
12456 
12457  return(self->f->pushBool(self,value));
12458 }
12459 
12460 smallArrayt* pushDoubleSmallArrayG (smallArrayt *self, double value) {
12461 
12462  return(self->f->pushDouble(self,value));
12463 }
12464 
12465 smallArrayt* pushIntSmallArrayG (smallArrayt *self, int64_t value) {
12466 
12467  return(self->f->pushInt(self,value));
12468 }
12469 
12470 smallArrayt* pushSSmallArrayG (smallArrayt *self, const char *string) {
12471 
12472  return(self->f->pushS(self,string));
12473 }
12474 
12475 smallArrayt* pushCharSmallArrayG(smallArrayt *self, char c) {
12476 
12477  return(self->f->pushChar(self,c));
12478 }
12479 
12480 smallArrayt* pushDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
12481 
12482  return(self->f->pushDict(self,dict));
12483 }
12484 
12485 smallArrayt* pushArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
12486 
12487  return(self->f->pushArray(self,array));
12488 }
12489 
12490 smallArrayt* pushArraycSmallArrayG (smallArrayt *self, char **array) {
12491 
12492  return(self->f->pushArrayc(self,array));
12493 }
12494 
12495 smallArrayt* pushCArraycSmallArrayG (smallArrayt *self, const char **array) {
12496 
12497  return(self->f->pushCArrayc(self,array));
12498 }
12499 
12500 smallArrayt* pushVoidSmallArrayG (smallArrayt *self, void *value) {
12501 
12502  if (value) {
12503  smallContainert *c = allocSmallContainer(value);
12504  if (!c) {
12505  return(NULL);
12506  }
12507  return(self->f->pushNFreeSmallContainer(self, c));
12508  }
12509  return(self->f->pushUndefined(self));
12510 }
12511 
12512 smallArrayt* pushSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
12513 
12514  return(self->f->pushSmallBool(self,value));
12515 }
12516 
12517 smallArrayt* pushSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
12518 
12519  return(self->f->pushSmallBytes(self,value));
12520 }
12521 
12522 smallArrayt* pushSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
12523 
12524  return(self->f->pushSmallDouble(self,value));
12525 }
12526 
12527 smallArrayt* pushSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
12528 
12529  return(self->f->pushSmallInt(self,value));
12530 }
12531 
12532 smallArrayt* pushSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value) {
12533 
12534  return(self->f->pushSmallJson(self,value));
12535 }
12536 
12537 smallArrayt* pushSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
12538 
12539  return(self->f->pushSmallString(self,string));
12540 }
12541 
12542 smallArrayt* pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
12543 
12544  return(self->f->pushSmallContainer(self,container));
12545 }
12546 
12547 
12548 smallArrayt* pushNFreeSmallArrayG (smallArrayt *self, baset *value) {
12549 
12550  return(self->f->pushNFree(self,value));
12551 }
12552 
12553 smallArrayt* pushNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) {
12554 
12555  return(self->f->pushNFreeUndefined(self,value));
12556 }
12557 
12558 smallArrayt* pushNFreeSSmallArrayG (smallArrayt *self, char *string) {
12559 
12560  return(self->f->pushNFreeS(self,string));
12561 }
12562 
12563 smallArrayt* pushNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
12564 
12565  return(self->f->pushNFreeDict(self,dict));
12566 }
12567 
12568 smallArrayt* pushNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
12569 
12570  return(self->f->pushNFreeArray(self,array));
12571 }
12572 
12573 smallArrayt* pushNFreeArraycSmallArrayG (smallArrayt *self, char **array) {
12574 
12575  return(self->f->pushNFreeArrayc(self,array));
12576 }
12577 
12578 smallArrayt* pushNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
12579 
12580  return(self->f->pushNFreeSmallBool(self,value));
12581 }
12582 
12583 smallArrayt* pushNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
12584 
12585  return(self->f->pushNFreeSmallBytes(self,value));
12586 }
12587 
12588 smallArrayt* pushNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
12589 
12590  return(self->f->pushNFreeSmallDouble(self,value));
12591 }
12592 
12593 smallArrayt* pushNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
12594 
12595  return(self->f->pushNFreeSmallInt(self,value));
12596 }
12597 
12598 smallArrayt* pushNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value) {
12599 
12600  return(self->f->pushNFreeSmallJson(self,value));
12601 }
12602 
12603 smallArrayt* pushNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
12604 
12605  return(self->f->pushNFreeSmallString(self,string));
12606 }
12607 
12608 smallArrayt* pushNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
12609 
12610  return(self->f->pushNFreeSmallContainer(self,container));
12611 }
12612 
12613 
12614 
12615 baset* popSmallArrayG (smallArrayt *self, baset* retType UNUSED) {
12616 
12617  return(self->f->pop(self));
12618 }
12619 
12620 undefinedt* popUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED) {
12621 
12622  return(self->f->popUndefined(self));
12623 }
12624 
12625 bool popBoolSmallArrayG (smallArrayt *self, bool retType UNUSED) {
12626 
12627  return(self->f->popBool(self));
12628 }
12629 
12630 double popDoubleSmallArrayG (smallArrayt *self, double retType UNUSED) {
12631 
12632  return(self->f->popDouble(self));
12633 }
12634 
12635 int64_t popIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED) {
12636 
12637  return(self->f->popInt(self));
12638 }
12639 
12640 int32_t popInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED) {
12641 
12642  return(self->f->popInt32(self));
12643 }
12644 
12645 uint64_t popUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED) {
12646 
12647  return(self->f->popUint(self));
12648 }
12649 
12650 uint32_t popUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED) {
12651 
12652  return(self->f->popUint32(self));
12653 }
12654 
12655 char* popSSmallArrayG (smallArrayt *self, char* retType UNUSED) {
12656 
12657  return(self->f->popS(self));
12658 }
12659 
12660 smallDictt* popDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED) {
12661 
12662  return(self->f->popDict(self));
12663 }
12664 
12665 smallArrayt* popArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED) {
12666 
12667  return(self->f->popArray(self));
12668 }
12669 
12670 smallBoolt* popSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED) {
12671 
12672  return(self->f->popSmallBool(self));
12673 }
12674 
12675 smallBytest* popSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED) {
12676 
12677  return(self->f->popSmallBytes(self));
12678 }
12679 
12680 smallDoublet* popSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED) {
12681 
12682  return(self->f->popSmallDouble(self));
12683 }
12684 
12685 smallIntt* popSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED) {
12686 
12687  return(self->f->popSmallInt(self));
12688 }
12689 
12690 smallJsont* popSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED) {
12691 
12692  return(self->f->popSmallJson(self));
12693 }
12694 
12695 smallStringt* popSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED) {
12696 
12697  return(self->f->popSmallString(self));
12698 }
12699 
12700 void* popVoidSmallArrayG (smallArrayt *self, void* retType UNUSED) {
12701 
12702  return(self->f->popVoid(self));
12703 }
12704 
12705 smallContainert* popSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED) {
12706 
12707  return(self->f->popSmallContainer(self));
12708 }
12709 
12710 
12711 smallArrayt* prependSmallArrayG (smallArrayt *self, baset *value) {
12712 
12713  return(self->f->prepend(self, value));
12714 }
12715 
12716 smallArrayt* prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED) {
12717 
12718  return(self->f->prependUndefined(self));
12719 }
12720 
12721 smallArrayt* prependBoolSmallArrayG (smallArrayt *self, bool value) {
12722 
12723  return(self->f->prependBool(self,value));
12724 }
12725 
12726 smallArrayt* prependDoubleSmallArrayG (smallArrayt *self, double value) {
12727 
12728  return(self->f->prependDouble(self,value));
12729 }
12730 
12731 smallArrayt* prependIntSmallArrayG (smallArrayt *self, int64_t value) {
12732 
12733  return(self->f->prependInt(self,value));
12734 }
12735 
12736 smallArrayt* prependSSmallArrayG (smallArrayt *self, const char *string) {
12737 
12738  return(self->f->prependS(self,string));
12739 }
12740 
12741 smallArrayt* prependCharSmallArrayG(smallArrayt *self, char c) {
12742 
12743  return(self->f->prependChar(self,c));
12744 }
12745 
12746 smallArrayt* prependDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
12747 
12748  return(self->f->prependDict(self,dict));
12749 }
12750 
12751 smallArrayt* prependArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
12752 
12753  return(self->f->prependArray(self,array));
12754 }
12755 
12756 smallArrayt* prependArraycSmallArrayG (smallArrayt *self, char **array) {
12757 
12758  return(self->f->prependArrayc(self,array));
12759 }
12760 
12761 smallArrayt* prependCArraycSmallArrayG (smallArrayt *self, const char **array) {
12762 
12763  return(self->f->prependCArrayc(self,array));
12764 }
12765 
12766 smallArrayt* prependVoidSmallArrayG (smallArrayt *self, void *value) {
12767 
12768  if (value) {
12769  smallContainert *c = allocSmallContainer(value);
12770  if (!c) {
12771  return(NULL);
12772  }
12773  return(self->f->prependNFreeSmallContainer(self, c));
12774  }
12775  return(self->f->prependUndefined(self));
12776 }
12777 
12778 smallArrayt* prependSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
12779 
12780  return(self->f->prependSmallBool(self,value));
12781 }
12782 
12783 smallArrayt* prependSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
12784 
12785  return(self->f->prependSmallBytes(self,value));
12786 }
12787 
12788 smallArrayt* prependSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
12789 
12790  return(self->f->prependSmallDouble(self,value));
12791 }
12792 
12793 smallArrayt* prependSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
12794 
12795  return(self->f->prependSmallInt(self,value));
12796 }
12797 
12798 smallArrayt* prependSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
12799 
12800  return(self->f->prependSmallJson(self,json));
12801 }
12802 
12803 smallArrayt* prependSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
12804 
12805  return(self->f->prependSmallString(self,string));
12806 }
12807 
12808 smallArrayt* prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
12809 
12810  return(self->f->prependSmallContainer(self,container));
12811 }
12812 
12813 
12814 smallArrayt* prependNFreeSmallArrayG (smallArrayt *self, baset *value) {
12815 
12816  return(self->f->prependNFree(self,value));
12817 }
12818 
12819 smallArrayt* prependNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) {
12820 
12821  return(self->f->prependNFreeUndefined(self,value));
12822 }
12823 
12824 smallArrayt* prependNFreeSSmallArrayG (smallArrayt *self, char *string) {
12825 
12826  return(self->f->prependNFreeS(self,string));
12827 }
12828 
12829 smallArrayt* prependNFreeDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
12830 
12831  return(self->f->prependNFreeDict(self,dict));
12832 }
12833 
12834 smallArrayt* prependNFreeArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
12835 
12836  return(self->f->prependNFreeArray(self,array));
12837 }
12838 
12839 smallArrayt* prependNFreeArraycSmallArrayG (smallArrayt *self, char **array) {
12840 
12841  return(self->f->prependNFreeArrayc(self,array));
12842 }
12843 
12844 smallArrayt* prependNFreeSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
12845 
12846  return(self->f->prependNFreeSmallBool(self,value));
12847 }
12848 
12849 smallArrayt* prependNFreeSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
12850 
12851  return(self->f->prependNFreeSmallBytes(self,value));
12852 }
12853 
12854 smallArrayt* prependNFreeSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
12855 
12856  return(self->f->prependNFreeSmallDouble(self,value));
12857 }
12858 
12859 smallArrayt* prependNFreeSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
12860 
12861  return(self->f->prependNFreeSmallInt(self,value));
12862 }
12863 
12864 smallArrayt* prependNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
12865 
12866  return(self->f->prependNFreeSmallJson(self,json));
12867 }
12868 
12869 smallArrayt* prependNFreeSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
12870 
12871  return(self->f->prependNFreeSmallString(self,string));
12872 }
12873 
12874 smallArrayt* prependNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
12875 
12876  return(self->f->prependNFreeSmallContainer(self,container));
12877 }
12878 
12879 
12880 
12881 baset* dequeueSmallArrayG (smallArrayt *self, baset* retType UNUSED) {
12882 
12883  return(self->f->dequeue(self));
12884 }
12885 
12886 undefinedt* dequeueUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED) {
12887 
12888  return(self->f->dequeueUndefined(self));
12889 }
12890 
12891 bool dequeueBoolSmallArrayG (smallArrayt *self, bool retType UNUSED) {
12892 
12893  return(self->f->dequeueBool(self));
12894 }
12895 
12896 double dequeueDoubleSmallArrayG (smallArrayt *self, double retType UNUSED) {
12897 
12898  return(self->f->dequeueDouble(self));
12899 }
12900 
12901 int64_t dequeueIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED) {
12902 
12903  return(self->f->dequeueInt(self));
12904 }
12905 
12906 int32_t dequeueInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED) {
12907 
12908  return(self->f->dequeueInt32(self));
12909 }
12910 
12911 uint64_t dequeueUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED) {
12912 
12913  return(self->f->dequeueUint(self));
12914 }
12915 
12916 uint32_t dequeueUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED) {
12917 
12918  return(self->f->dequeueUint32(self));
12919 }
12920 
12921 char* dequeueSSmallArrayG (smallArrayt *self, char* retType UNUSED) {
12922 
12923  return(self->f->dequeueS(self));
12924 }
12925 
12926 smallDictt* dequeueDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED) {
12927 
12928  return(self->f->dequeueDict(self));
12929 }
12930 
12931 smallArrayt* dequeueArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED) {
12932 
12933  return(self->f->dequeueArray(self));
12934 }
12935 
12936 smallBoolt* dequeueSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED) {
12937 
12938  return(self->f->dequeueSmallBool(self));
12939 }
12940 
12941 smallBytest* dequeueSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED) {
12942 
12943  return(self->f->dequeueSmallBytes(self));
12944 }
12945 
12946 smallDoublet* dequeueSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED) {
12947 
12948  return(self->f->dequeueSmallDouble(self));
12949 }
12950 
12951 smallIntt* dequeueSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED) {
12952 
12953  return(self->f->dequeueSmallInt(self));
12954 }
12955 
12956 smallJsont* dequeueSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED) {
12957 
12958  return(self->f->dequeueSmallJson(self));
12959 }
12960 
12961 smallStringt* dequeueSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED) {
12962 
12963  return(self->f->dequeueSmallString(self));
12964 }
12965 
12966 void* dequeueVoidSmallArrayG (smallArrayt *self, void* retType UNUSED) {
12967 
12968  return(self->f->dequeueVoid(self));
12969 }
12970 
12971 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED) {
12972 
12973  return(self->f->dequeueSmallContainer(self));
12974 }
12975 
12976 
12977 
12978 
12979 baset* getAtSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index) {
12980 
12981  return(self->f->getAt(self,index));
12982 }
12983 
12984 undefinedt* getAtUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) {
12985 
12986  return(self->f->getAtUndefined(self,index));
12987 }
12988 
12989 bool getAtBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index) {
12990 
12991  return(self->f->getAtBool(self,index));
12992 }
12993 
12994 bool* getAtBoolPSmallArrayG (smallArrayt *self, bool* retType UNUSED, int64_t index) {
12995 
12996  return(self->f->getAtBoolP(self,index));
12997 }
12998 
12999 double getAtDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index) {
13000 
13001  return(self->f->getAtDouble(self,index));
13002 }
13003 
13004 double* getAtDoublePSmallArrayG (smallArrayt *self, double* retType UNUSED, int64_t index) {
13005 
13006  return(self->f->getAtDoubleP(self,index));
13007 }
13008 
13009 int64_t getAtIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index) {
13010 
13011  return(self->f->getAtInt(self,index));
13012 }
13013 
13014 int64_t* getAtIntPSmallArrayG (smallArrayt *self, int64_t* retType UNUSED, int64_t index) {
13015 
13016  return(self->f->getAtIntP(self,index));
13017 }
13018 
13019 int32_t getAtInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index) {
13020 
13021  return(self->f->getAtInt32(self,index));
13022 }
13023 
13024 int32_t* getAtInt32PSmallArrayG (smallArrayt *self, int32_t* retType UNUSED, int64_t index) {
13025 
13026  return(self->f->getAtInt32P(self,index));
13027 }
13028 
13029 uint64_t getAtUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index) {
13030 
13031  return(self->f->getAtUint(self,index));
13032 }
13033 
13034 uint64_t* getAtUintPSmallArrayG (smallArrayt *self, uint64_t* retType UNUSED, int64_t index) {
13035 
13036  return(self->f->getAtUintP(self,index));
13037 }
13038 
13039 uint32_t getAtUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index) {
13040 
13041  return(self->f->getAtUint32(self,index));
13042 }
13043 
13044 uint32_t* getAtUint32PSmallArrayG (smallArrayt *self, uint32_t* retType UNUSED, int64_t index) {
13045 
13046  return(self->f->getAtUint32P(self,index));
13047 }
13048 
13049 char* getAtSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index) {
13050 
13051  return(self->f->getAtS(self,index));
13052 }
13053 
13054 smallDictt* getAtDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) {
13055 
13056  return(self->f->getAtDict(self,index));
13057 }
13058 
13059 smallArrayt* getAtArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) {
13060 
13061  return(self->f->getAtArray(self,index));
13062 }
13063 
13064 smallBoolt* getAtSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) {
13065 
13066  return(self->f->getAtSmallBool(self,index));
13067 }
13068 
13069 smallBytest* getAtSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) {
13070 
13071  return(self->f->getAtSmallBytes(self,index));
13072 }
13073 
13074 smallDoublet* getAtSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) {
13075 
13076  return(self->f->getAtSmallDouble(self,index));
13077 }
13078 
13079 smallIntt* getAtSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) {
13080 
13081  return(self->f->getAtSmallInt(self,index));
13082 }
13083 
13084 smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index) {
13085 
13086  return(self->f->getAtSmallJson(self,index));
13087 }
13088 
13089 smallStringt* getAtSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) {
13090 
13091  return(self->f->getAtSmallString(self,index));
13092 }
13093 
13094 void* getAtVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index) {
13095 
13096  return(self->f->getAtVoid(self,index));
13097 }
13098 
13099 smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) {
13100 
13101  return(self->f->getAtSmallContainer(self,index));
13102 }
13103 
13104 
13105 baset* getAtNDupSmallArrayG (smallArrayt *self, baset* retType UNUSED, int64_t index) {
13106 
13107  return(self->f->getAtNDup(self,index));
13108 }
13109 
13110 undefinedt* getAtNDupUndefinedSmallArrayG (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) {
13111 
13112  return(self->f->getAtNDupUndefined(self,index));
13113 }
13114 
13115 bool getAtNDupBoolSmallArrayG (smallArrayt *self, bool retType UNUSED, int64_t index) {
13116 
13117  return(self->f->getAtNDupBool(self,index));
13118 }
13119 
13120 double getAtNDupDoubleSmallArrayG (smallArrayt *self, double retType UNUSED, int64_t index) {
13121 
13122  return(self->f->getAtNDupDouble(self,index));
13123 }
13124 
13125 int64_t getAtNDupIntSmallArrayG (smallArrayt *self, int64_t retType UNUSED, int64_t index) {
13126 
13127  return(self->f->getAtNDupInt(self,index));
13128 }
13129 
13130 int32_t getAtNDupInt32SmallArrayG (smallArrayt *self, int32_t retType UNUSED, int64_t index) {
13131 
13132  return(self->f->getAtNDupInt32(self,index));
13133 }
13134 
13135 uint64_t getAtNDupUintSmallArrayG (smallArrayt *self, uint64_t retType UNUSED, int64_t index) {
13136 
13137  return(self->f->getAtNDupUint(self,index));
13138 }
13139 
13140 uint32_t getAtNDupUint32SmallArrayG (smallArrayt *self, uint32_t retType UNUSED, int64_t index) {
13141 
13142  return(self->f->getAtNDupUint32(self,index));
13143 }
13144 
13145 char* getAtNDupSSmallArrayG (smallArrayt *self, char* retType UNUSED, int64_t index) {
13146 
13147  return(self->f->getAtNDupS(self,index));
13148 }
13149 
13150 smallDictt* getAtNDupDictSmallArrayG (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) {
13151 
13152  return(self->f->getAtNDupDict(self,index));
13153 }
13154 
13155 smallArrayt* getAtNDupArraySmallArrayG (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) {
13156 
13157  return(self->f->getAtNDupArray(self,index));
13158 }
13159 
13160 smallBoolt* getAtNDupSmallBoolSmallArrayG (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) {
13161 
13162  return(self->f->getAtNDupSmallBool(self,index));
13163 }
13164 
13165 smallBytest* getAtNDupSmallBytesSmallArrayG (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) {
13166 
13167  return(self->f->getAtNDupSmallBytes(self,index));
13168 }
13169 
13170 smallDoublet* getAtNDupSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) {
13171 
13172  return(self->f->getAtNDupSmallDouble(self,index));
13173 }
13174 
13175 smallIntt* getAtNDupSmallIntSmallArrayG (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) {
13176 
13177  return(self->f->getAtNDupSmallInt(self,index));
13178 }
13179 
13180 smallJsont* getAtNDupSmallJsonSmallArrayG (smallArrayt *self, smallJsont* retType UNUSED, int64_t index) {
13181 
13182  return(self->f->getAtNDupSmallJson(self,index));
13183 }
13184 
13185 smallStringt* getAtNDupSmallStringSmallArrayG (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) {
13186 
13187  return(self->f->getAtNDupSmallString(self,index));
13188 }
13189 
13190 void* getAtNDupVoidSmallArrayG (smallArrayt *self, void* retType UNUSED, int64_t index) {
13191 
13192  return(self->f->getAtNDupVoid(self,index));
13193 }
13194 
13195 smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) {
13196 
13197  return(self->f->getAtNDupSmallContainer(self,index));
13198 }
13199 
13200 smallArrayt* setAtSmallArrayG (smallArrayt *self, int64_t index, baset *value) {
13201 
13202  return(self->f->setAt(self, index, value));
13203 }
13204 
13205 smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) {
13206 
13207  return(self->f->setAtUndefined(self,index));
13208 }
13209 
13210 smallArrayt* setAtBoolSmallArrayG (smallArrayt *self, int64_t index, bool value) {
13211 
13212  return(self->f->setAtBool(self,index,value));
13213 }
13214 
13215 smallArrayt* setAtDoubleSmallArrayG (smallArrayt *self, int64_t index, double value) {
13216 
13217  return(self->f->setAtDouble(self,index,value));
13218 }
13219 
13220 smallArrayt* setAtIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value) {
13221 
13222  return(self->f->setAtInt(self,index,value));
13223 }
13224 
13225 smallArrayt* setAtSSmallArrayG (smallArrayt *self, int64_t index, const char *string) {
13226 
13227  return(self->f->setAtS(self,index,string));
13228 }
13229 
13230 smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c) {
13231 
13232  return(self->f->setAtChar(self,index,c));
13233 }
13234 
13235 smallArrayt* setAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13236 
13237  return(self->f->setAtDict(self,index,dict));
13238 }
13239 
13240 smallArrayt* setAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13241 
13242  return(self->f->setAtArray(self,index,array));
13243 }
13244 
13245 smallArrayt* setAtArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) {
13246 
13247  return(self->f->setAtArrayc(self,index,array));
13248 }
13249 
13250 smallArrayt* setAtCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array) {
13251 
13252  return(self->f->setAtCArrayc(self,index,array));
13253 }
13254 
13255 smallArrayt* setAtVoidSmallArrayG (smallArrayt *self, int64_t index, void *value) {
13256 
13257  if (value) {
13258  smallContainert *c = allocSmallContainer(value);
13259  if (!c) {
13260  return(NULL);
13261  }
13262  return(self->f->setAtNFreeSmallContainer(self, index, c));
13263  }
13264  return(self->f->setAtUndefined(self,index));
13265 }
13266 
13267 smallArrayt* setAtSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) {
13268 
13269  return(self->f->setAtSmallBool(self,index,value));
13270 }
13271 
13272 smallArrayt* setAtSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) {
13273 
13274  return(self->f->setAtSmallBytes(self,index,value));
13275 }
13276 
13277 smallArrayt* setAtSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) {
13278 
13279  return(self->f->setAtSmallDouble(self,index,value));
13280 }
13281 
13282 smallArrayt* setAtSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) {
13283 
13284  return(self->f->setAtSmallInt(self,index,value));
13285 }
13286 
13287 smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) {
13288 
13289  return(self->f->setAtSmallJson(self,index,value));
13290 }
13291 
13292 smallArrayt* setAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13293 
13294  return(self->f->setAtSmallString(self,index,string));
13295 }
13296 
13297 smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
13298 
13299  return(self->f->setAtSmallContainer(self,index,container));
13300 }
13301 
13302 
13303 smallArrayt* setAtNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value) {
13304 
13305  return(self->f->setAtNFree(self,index,value));
13306 }
13307 
13308 smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value) {
13309 
13310  return(self->f->setAtNFreeUndefined(self,index,value));
13311 }
13312 
13313 smallArrayt* setAtNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string) {
13314 
13315  return(self->f->setAtNFreeS(self,index,string));
13316 }
13317 
13318 smallArrayt* setAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13319 
13320  return(self->f->setAtNFreeDict(self,index,dict));
13321 }
13322 
13323 smallArrayt* setAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13324 
13325  return(self->f->setAtNFreeArray(self,index,array));
13326 }
13327 
13328 smallArrayt* setAtNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) {
13329 
13330  return(self->f->setAtNFreeArrayc(self,index,array));
13331 }
13332 
13333 smallArrayt* setAtNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) {
13334 
13335  return(self->f->setAtNFreeSmallBool(self,index,value));
13336 }
13337 
13338 smallArrayt* setAtNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) {
13339 
13340  return(self->f->setAtNFreeSmallBytes(self,index,value));
13341 }
13342 
13343 smallArrayt* setAtNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) {
13344 
13345  return(self->f->setAtNFreeSmallDouble(self,index,value));
13346 }
13347 
13348 smallArrayt* setAtNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) {
13349 
13350  return(self->f->setAtNFreeSmallInt(self,index,value));
13351 }
13352 
13353 smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) {
13354 
13355  return(self->f->setAtNFreeSmallJson(self,index,value));
13356 }
13357 
13358 smallArrayt* setAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13359 
13360  return(self->f->setAtNFreeSmallString(self,index,string));
13361 }
13362 
13363 smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
13364 
13365  return(self->f->setAtNFreeSmallContainer(self,index,container));
13366 }
13367 
13368 
13369 smallArrayt* setPAtDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13370 
13371  return(self->f->setPAtDict(self,index,dict));
13372 }
13373 
13374 smallArrayt* setPAtArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13375 
13376  return(self->f->setPAtArray(self,index,array));
13377 }
13378 
13379 smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) {
13380 
13381  return(self->f->setPAtSmallJson(self,index,json));
13382 }
13383 
13384 smallArrayt* setPAtSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13385 
13386  return(self->f->setPAtSmallString(self,index,string));
13387 }
13388 
13389 smallArrayt* setPAtNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13390 
13391  return(self->f->setPAtNFreeDict(self,index,dict));
13392 }
13393 
13394 smallArrayt* setPAtNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13395 
13396  return(self->f->setPAtNFreeArray(self,index,array));
13397 }
13398 
13399 smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) {
13400 
13401  return(self->f->setPAtNFreeSmallJson(self,index,json));
13402 }
13403 
13404 smallArrayt* setPAtNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13405 
13406  return(self->f->setPAtNFreeSmallString(self,index,string));
13407 }
13408 
13409 double getNumSmallArrayG(smallArrayt *self, int64_t index) {
13410 
13411  return(self->f->getNum(self, index));
13412 }
13413 
13414 smallArrayt* reverseSmallArrayG (smallArrayt *self) {
13415 
13416  return(self->f->reverse(self));
13417 }
13418 
13419 smallArrayt* appendSmallArrayG (smallArrayt *self, smallArrayt *array) {
13420 
13421  return(self->f->append(self, array));
13422 }
13423 
13424 smallArrayt* appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
13425 
13426  return(self->f->appendSmallJson(self, json));
13427 }
13428 
13429 smallArrayt* appendNSmashSmallArrayG (smallArrayt *self, smallArrayt *array) {
13430 
13431  return(self->f->appendNSmash(self,array));
13432 }
13433 
13434 smallArrayt* appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
13435 
13436  return(self->f->appendNSmashSmallJson(self,json));
13437 }
13438 
13439 smallArrayt* appendArraySmallArrayG (smallArrayt *self, char **array) {
13440 
13441  return(self->f->appendArray(self, array));
13442 }
13443 
13444 smallArrayt* appendNSmashArraySmallArrayG (smallArrayt *self, char **array) {
13445 
13446  return(self->f->appendNSmashArray(self,array));
13447 }
13448 
13449 smallArrayt* appendCArraySmallArrayG (smallArrayt *self, const char **array) {
13450 
13451  return(self->f->appendCArray(self, array));
13452 }
13453 
13454 smallArrayt* shiftSmallArrayG (smallArrayt *self, smallArrayt *array) {
13455 
13456  return(self->f->shift(self, array)); {
13457  // cg c bug if
13458 }
13459  }
13460 
13461 smallArrayt* shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
13462 
13463  return(self->f->shiftSmallJson(self, json)); {
13464  // cg c bug if
13465 }
13466  }
13467 
13468 smallArrayt* shiftNSmashSmallArrayG (smallArrayt *self, smallArrayt *array) {
13469 
13470  return(self->f->shiftNSmash(self,array)); {
13471  // cg c bug if
13472 }
13473  }
13474 
13475 smallArrayt* shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json) {
13476 
13477  return(self->f->shiftNSmashSmallJson(self,json)); {
13478  // cg c bug if
13479 }
13480  }
13481 
13482 smallArrayt* addSmallArrayG (smallArrayt *self, smallArrayt *array) {
13483 
13484  return(self->f->add(self, array));
13485 }
13486 
13487 smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end) {
13488 
13489  return(self->f->slice(self, start, end));
13490 }
13491 
13492 smallArrayt* cropSmallArrayG (smallArrayt *self, int64_t start, int64_t end) {
13493 
13494  return(self->f->crop(self, start, end));
13495 }
13496 
13497 baset* cropElemSmallArrayG (smallArrayt *self, int64_t index) {
13498 
13499  return(self->f->cropElem(self, index));
13500 }
13501 
13502 undefinedt* cropElemUndefinedSmallArrayG (smallArrayt *self, int64_t index) {
13503 
13504  return(self->f->cropElemUndefined(self, index));
13505 }
13506 
13507 bool cropElemBoolSmallArrayG (smallArrayt *self, int64_t index) {
13508 
13509  return(self->f->cropElemBool(self, index));
13510 }
13511 
13512 double cropElemDoubleSmallArrayG (smallArrayt *self, int64_t index) {
13513 
13514  return(self->f->cropElemDouble(self, index));
13515 }
13516 
13517 int64_t cropElemIntSmallArrayG (smallArrayt *self, int64_t index) {
13518 
13519  return(self->f->cropElemInt(self, index));
13520 }
13521 
13522 int32_t cropElemInt32SmallArrayG (smallArrayt *self, int64_t index) {
13523 
13524  return(self->f->cropElemInt32(self, index));
13525 }
13526 
13527 uint64_t cropElemUintSmallArrayG (smallArrayt *self, int64_t index) {
13528 
13529  return(self->f->cropElemUint(self, index));
13530 }
13531 
13532 uint32_t cropElemUint32SmallArrayG (smallArrayt *self, int64_t index) {
13533 
13534  return(self->f->cropElemUint32(self, index));
13535 }
13536 
13537 char* cropElemSSmallArrayG (smallArrayt *self, int64_t index) {
13538 
13539  return(self->f->cropElemS(self, index));
13540 }
13541 
13542 smallDictt* cropElemDictSmallArrayG (smallArrayt *self, int64_t index) {
13543 
13544  return(self->f->cropElemDict(self, index));
13545 }
13546 
13547 smallArrayt* cropElemArraySmallArrayG (smallArrayt *self, int64_t index) {
13548 
13549  return(self->f->cropElemArray(self, index));
13550 }
13551 
13552 smallBoolt* cropElemSmallBoolSmallArrayG (smallArrayt *self, int64_t index) {
13553 
13554  return(self->f->cropElemSmallBool(self, index));
13555 }
13556 
13557 smallBytest* cropElemSmallBytesSmallArrayG (smallArrayt *self, int64_t index) {
13558 
13559  return(self->f->cropElemSmallBytes(self, index));
13560 }
13561 
13562 smallDoublet* cropElemSmallDoubleSmallArrayG (smallArrayt *self, int64_t index) {
13563 
13564  return(self->f->cropElemSmallDouble(self, index));
13565 }
13566 
13567 smallIntt* cropElemSmallIntSmallArrayG (smallArrayt *self, int64_t index) {
13568 
13569  return(self->f->cropElemSmallInt(self, index));
13570 }
13571 
13572 smallJsont* cropElemSmallJsonSmallArrayG (smallArrayt *self, int64_t index) {
13573 
13574  return(self->f->cropElemSmallJson(self, index));
13575 }
13576 
13577 smallStringt* cropElemSmallStringSmallArrayG (smallArrayt *self, int64_t index) {
13578 
13579  return(self->f->cropElemSmallString(self, index));
13580 }
13581 
13582 void* cropElemVoidSmallArrayG (smallArrayt *self, int64_t index) {
13583 
13584  return(self->f->cropElemVoid(self, index));
13585 }
13586 
13587 smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index) {
13588 
13589  return(self->f->cropElemSmallContainer(self, index));
13590 }
13591 
13592 smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end) {
13593 
13594  return(self->f->copy(self, start, end));
13595 }
13596 
13597 smallArrayt* insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
13598 
13599  return(self->f->insert(self, index, toInsert));
13600 }
13601 
13602 smallArrayt* insertSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *toInsert) {
13603 
13604  return(self->f->insertSmallJson(self, index, toInsert));
13605 }
13606 
13607 smallArrayt* insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
13608 
13609  return(self->f->insertNSmash(self, index, toInsert));
13610 }
13611 
13612 smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert) {
13613 
13614  return(self->f->insertNSmashSmallJson(self, index, toInsert));
13615 }
13616 
13617 smallArrayt* injectSmallArrayG (smallArrayt *self, int64_t index, baset *value) {
13618 
13619  return(self->f->inject(self, index, value));
13620 }
13621 
13622 smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) {
13623 
13624  return(self->f->injectUndefined(self,index));
13625 }
13626 
13627 smallArrayt* injectBoolSmallArrayG (smallArrayt *self, int64_t index, bool value) {
13628 
13629  return(self->f->injectBool(self,index,value));
13630 }
13631 
13632 smallArrayt* injectDoubleSmallArrayG (smallArrayt *self, int64_t index, double value) {
13633 
13634  return(self->f->injectDouble(self,index,value));
13635 }
13636 
13637 smallArrayt* injectIntSmallArrayG (smallArrayt *self, int64_t index, int64_t value) {
13638 
13639  return(self->f->injectInt(self,index,value));
13640 }
13641 
13642 smallArrayt* injectSSmallArrayG (smallArrayt *self, int64_t index, const char *string) {
13643 
13644  return(self->f->injectS(self,index,string));
13645 }
13646 
13647 smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c) {
13648 
13649  return(self->f->injectChar(self,index,c));
13650 }
13651 
13652 smallArrayt* injectDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13653 
13654  return(self->f->injectDict(self,index,dict));
13655 }
13656 
13657 smallArrayt* injectArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13658 
13659  return(self->f->injectArray(self,index,array));
13660 }
13661 
13662 smallArrayt* injectArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) {
13663 
13664  return(self->f->injectArrayc(self,index,array));
13665 }
13666 
13667 smallArrayt* injectCArraycSmallArrayG (smallArrayt *self, int64_t index, const char **array) {
13668 
13669  return(self->f->injectCArrayc(self,index,array));
13670 }
13671 
13672 smallArrayt* injectVoidSmallArrayG (smallArrayt *self, int64_t index, void *value) {
13673 
13674  if (value) {
13675  smallContainert *c = allocSmallContainer(value);
13676  if (!c) {
13677  return(NULL);
13678  }
13679  return(self->f->injectNFreeSmallContainer(self, index, c));
13680  }
13681  return(self->f->injectUndefined(self,index));
13682 }
13683 
13684 smallArrayt* injectSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) {
13685 
13686  return(self->f->injectSmallBool(self,index,value));
13687 }
13688 
13689 smallArrayt* injectSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) {
13690 
13691  return(self->f->injectSmallBytes(self,index,value));
13692 }
13693 
13694 smallArrayt* injectSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) {
13695 
13696  return(self->f->injectSmallDouble(self,index,value));
13697 }
13698 
13699 smallArrayt* injectSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) {
13700 
13701  return(self->f->injectSmallInt(self,index,value));
13702 }
13703 
13704 smallArrayt* injectSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string) {
13705 
13706  return(self->f->injectSmallJson(self,index,string));
13707 }
13708 
13709 smallArrayt* injectSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13710 
13711  return(self->f->injectSmallString(self,index,string));
13712 }
13713 
13714 smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
13715 
13716  return(self->f->injectSmallContainer(self,index,container));
13717 }
13718 
13719 
13720 smallArrayt* injectNFreeSmallArrayG (smallArrayt *self, int64_t index, baset *value) {
13721 
13722  return(self->f->injectNFree(self,index,value));
13723 }
13724 
13725 smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value) {
13726 
13727  return(self->f->injectNFreeUndefined(self,index,value));
13728 }
13729 
13730 smallArrayt* injectNFreeSSmallArrayG (smallArrayt *self, int64_t index, char *string) {
13731 
13732  return(self->f->injectNFreeS(self,index,string));
13733 }
13734 
13735 smallArrayt* injectNFreeDictSmallArrayG (smallArrayt *self, int64_t index, smallDictt *dict) {
13736 
13737  return(self->f->injectNFreeDict(self,index,dict));
13738 }
13739 
13740 smallArrayt* injectNFreeArraySmallArrayG (smallArrayt *self, int64_t index, smallArrayt *array) {
13741 
13742  return(self->f->injectNFreeArray(self,index,array));
13743 }
13744 
13745 smallArrayt* injectNFreeArraycSmallArrayG (smallArrayt *self, int64_t index, char **array) {
13746 
13747  return(self->f->injectNFreeArrayc(self,index,array));
13748 }
13749 
13750 smallArrayt* injectNFreeSmallBoolSmallArrayG (smallArrayt *self, int64_t index, smallBoolt *value) {
13751 
13752  return(self->f->injectNFreeSmallBool(self,index,value));
13753 }
13754 
13755 smallArrayt* injectNFreeSmallBytesSmallArrayG (smallArrayt *self, int64_t index, smallBytest *value) {
13756 
13757  return(self->f->injectNFreeSmallBytes(self,index,value));
13758 }
13759 
13760 smallArrayt* injectNFreeSmallDoubleSmallArrayG (smallArrayt *self, int64_t index, smallDoublet *value) {
13761 
13762  return(self->f->injectNFreeSmallDouble(self,index,value));
13763 }
13764 
13765 smallArrayt* injectNFreeSmallIntSmallArrayG (smallArrayt *self, int64_t index, smallIntt *value) {
13766 
13767  return(self->f->injectNFreeSmallInt(self,index,value));
13768 }
13769 
13770 smallArrayt* injectNFreeSmallJsonSmallArrayG (smallArrayt *self, int64_t index, smallJsont *string) {
13771 
13772  return(self->f->injectNFreeSmallJson(self,index,string));
13773 }
13774 
13775 smallArrayt* injectNFreeSmallStringSmallArrayG (smallArrayt *self, int64_t index, smallStringt *string) {
13776 
13777  return(self->f->injectNFreeSmallString(self,index,string));
13778 }
13779 
13780 smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
13781 
13782  return(self->f->injectNFreeSmallContainer(self,index,container));
13783 }
13784 
13785 smallArrayt* delSmallArrayG (smallArrayt *self, int64_t start, int64_t end) {
13786 
13787  return(self->f->del(self, start, end));
13788 }
13789 
13790 smallArrayt* delElemSmallArrayG (smallArrayt *self, int64_t index) {
13791 
13792  return(self->f->delElem(self, index));
13793 }
13794 
13795 smallArrayt* removeSmallArrayG (smallArrayt *self, int64_t start, int64_t end) {
13796 
13797  return(self->f->remove(self, start, end));
13798 }
13799 
13800 smallArrayt* removeElemSmallArrayG (smallArrayt *self, int64_t index) {
13801 
13802  return(self->f->removeElem(self, index));
13803 }
13804 
13805 smallArrayt* sortSmallArrayG (smallArrayt *self) {
13806 
13807  return(self->f->sort(self));
13808 }
13809 
13810 smallArrayt* sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction) {
13811 
13812  return(self->f->sortF(self,compareFunction));
13813 }
13814 
13815 smallArrayt* icSortSmallArrayG (smallArrayt *self) {
13816 
13817  return(self->f->icSort(self));
13818 }
13819 
13820 bool equalSmallArrayG (smallArrayt *self, smallArrayt *array) {
13821 
13822  return(self->f->equal(self, array));
13823 }
13824 
13825 bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array) {
13826 
13827  return(self->f->equalSmallJson(self, array));
13828 }
13829 
13830 bool equalSmallArrayArrayG(smallArrayt* self, char ** p2) {
13831 
13832  return(self->f->equalArray(self, p2));
13833 }
13834 
13835 bool equalSmallArrayCArrayG(smallArrayt* self, const char ** p2) {
13836 
13837  return(self->f->equalCArray(self, p2));
13838 }
13839 
13840 bool equalSmallArrayBaseG(smallArrayt* self, baset* p2) {
13841 
13842  return(self->f->equalBase(self, p2));
13843 }
13844 
13845 bool icEqualSmallArrayG (smallArrayt *self, smallArrayt *array) {
13846 
13847  return(self->f->icEqual(self, array));
13848 }
13849 
13850 bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array) {
13851 
13852  return(self->f->icEqualSmallJson(self, array));
13853 }
13854 
13855 bool icEqualSmallArrayArrayG(smallArrayt* self, char ** p2) {
13856 
13857  return(self->f->icEqualArray(self, p2));
13858 }
13859 
13860 bool icEqualSmallArrayCArrayG(smallArrayt* self, const char ** p2) {
13861 
13862  return(self->f->icEqualCArray(self, p2));
13863 }
13864 
13865 bool icEqualSmallArrayBaseG(smallArrayt* self, baset* p2) {
13866 
13867  return(self->f->icEqualBase(self, p2));
13868 }
13869 
13870 size_t lenSmallArrayG (smallArrayt *self) {
13871 
13872  return(self->f->len(self));
13873 }
13874 
13875 smallArrayt* trimSmallArrayG (smallArrayt *self) {
13876 
13877  return(self->f->trim(self));
13878 }
13879 
13880 bool hasSmallArrayG (smallArrayt *self, baset *value) {
13881 
13882  return(self->f->has(self, value));
13883 }
13884 
13885 bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) {
13886 
13887  return(self->f->hasUndefined(self, value));
13888 }
13889 
13890 bool hasBoolSmallArrayG (smallArrayt *self, bool value) {
13891 
13892  return(self->f->hasBool(self,value));
13893 }
13894 
13895 bool hasDoubleSmallArrayG (smallArrayt *self, double value) {
13896 
13897  return(self->f->hasDouble(self,value));
13898 }
13899 
13900 bool hasIntSmallArrayG (smallArrayt *self, int64_t value) {
13901 
13902  return(self->f->hasInt(self,value));
13903 }
13904 
13905 bool hasSSmallArrayG (smallArrayt *self, const char *string) {
13906 
13907  return(self->f->hasS(self,string));
13908 }
13909 
13910 bool hasCharSmallArrayG(smallArrayt *self, char c) {
13911 
13912  return(self->f->hasChar(self,c));
13913 }
13914 
13915 bool hasDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
13916 
13917  return(self->f->hasDict(self,dict));
13918 }
13919 
13920 bool hasArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
13921 
13922  return(self->f->hasArray(self,array));
13923 }
13924 
13925 bool hasArraycSmallArrayG (smallArrayt *self, char **array) {
13926 
13927  return(self->f->hasArrayc(self,array));
13928 }
13929 
13930 bool hasCArraycSmallArrayG (smallArrayt *self, const char **array) {
13931 
13932  return(self->f->hasCArrayc(self,array));
13933 }
13934 
13935 bool hasSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
13936 
13937  return(self->f->hasSmallBool(self,value));
13938 }
13939 
13940 bool hasSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
13941 
13942  return(self->f->hasSmallBytes(self,value));
13943 }
13944 
13945 bool hasSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
13946 
13947  return(self->f->hasSmallDouble(self,value));
13948 }
13949 
13950 bool hasSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
13951 
13952  return(self->f->hasSmallInt(self,value));
13953 }
13954 
13955 bool hasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
13956 
13957  return(self->f->hasSmallJson(self,string));
13958 }
13959 
13960 bool hasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
13961 
13962  return(self->f->hasSmallString(self,string));
13963 }
13964 
13965 bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
13966 
13967  return(self->f->hasSmallContainer(self,container));
13968 }
13969 
13970 ssize_t indexOfSmallArrayG (smallArrayt *self, baset *value) {
13971 
13972  return(self->f->indexOf(self, value));
13973 }
13974 
13975 ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) {
13976 
13977  return(self->f->indexOfUndefined(self, value));
13978 }
13979 
13980 ssize_t indexOfBoolSmallArrayG (smallArrayt *self, bool value) {
13981 
13982  return(self->f->indexOfBool(self,value));
13983 }
13984 
13985 ssize_t indexOfDoubleSmallArrayG (smallArrayt *self, double value) {
13986 
13987  return(self->f->indexOfDouble(self,value));
13988 }
13989 
13990 ssize_t indexOfIntSmallArrayG (smallArrayt *self, int64_t value) {
13991 
13992  return(self->f->indexOfInt(self,value));
13993 }
13994 
13995 ssize_t indexOfSSmallArrayG (smallArrayt *self, const char *string) {
13996 
13997  return(self->f->indexOfS(self,string));
13998 }
13999 
14000 ssize_t indexOfCharSmallArrayG(smallArrayt *self, char c) {
14001 
14002  return(self->f->indexOfChar(self,c));
14003 }
14004 
14005 ssize_t indexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
14006 
14007  return(self->f->indexOfDict(self,dict));
14008 }
14009 
14010 ssize_t indexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
14011 
14012  return(self->f->indexOfArray(self,array));
14013 }
14014 
14015 ssize_t indexOfArraycSmallArrayG (smallArrayt *self, char **array) {
14016 
14017  return(self->f->indexOfArrayc(self,array));
14018 }
14019 
14020 ssize_t indexOfCArraycSmallArrayG (smallArrayt *self, const char **array) {
14021 
14022  return(self->f->indexOfCArrayc(self,array));
14023 }
14024 
14025 ssize_t indexOfSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
14026 
14027  return(self->f->indexOfSmallBool(self,value));
14028 }
14029 
14030 ssize_t indexOfSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
14031 
14032  return(self->f->indexOfSmallBytes(self,value));
14033 }
14034 
14035 ssize_t indexOfSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
14036 
14037  return(self->f->indexOfSmallDouble(self,value));
14038 }
14039 
14040 ssize_t indexOfSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
14041 
14042  return(self->f->indexOfSmallInt(self,value));
14043 }
14044 
14045 ssize_t indexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
14046 
14047  return(self->f->indexOfSmallJson(self,string));
14048 }
14049 
14050 ssize_t indexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
14051 
14052  return(self->f->indexOfSmallString(self,string));
14053 }
14054 
14055 ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
14056 
14057  return(self->f->indexOfSmallContainer(self,container));
14058 }
14059 
14060 ssize_t binarySearchSmallArrayG (smallArrayt *self, baset *value) {
14061 
14062  return(self->f->binarySearch(self, value));
14063 }
14064 
14065 ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value) {
14066 
14067  return(self->f->binarySearchUndefined(self, value));
14068 }
14069 
14070 ssize_t binarySearchBoolSmallArrayG (smallArrayt *self, bool value) {
14071 
14072  return(self->f->binarySearchBool(self,value));
14073 }
14074 
14075 ssize_t binarySearchDoubleSmallArrayG (smallArrayt *self, double value) {
14076 
14077  return(self->f->binarySearchDouble(self,value));
14078 }
14079 
14080 ssize_t binarySearchIntSmallArrayG (smallArrayt *self, int64_t value) {
14081 
14082  return(self->f->binarySearchInt(self,value));
14083 }
14084 
14085 ssize_t binarySearchSSmallArrayG (smallArrayt *self, const char *string) {
14086 
14087  return(self->f->binarySearchS(self,string));
14088 }
14089 
14090 ssize_t binarySearchCharSmallArrayG(smallArrayt *self, char c) {
14091 
14092  return(self->f->binarySearchChar(self,c));
14093 }
14094 
14095 ssize_t binarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
14096 
14097  return(self->f->binarySearchDict(self,dict));
14098 }
14099 
14100 ssize_t binarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
14101 
14102  return(self->f->binarySearchArray(self,array));
14103 }
14104 
14105 ssize_t binarySearchArraycSmallArrayG (smallArrayt *self, char **array) {
14106 
14107  return(self->f->binarySearchArrayc(self,array));
14108 }
14109 
14110 ssize_t binarySearchCArraycSmallArrayG (smallArrayt *self, const char **array) {
14111 
14112  return(self->f->binarySearchCArrayc(self,array));
14113 }
14114 
14115 ssize_t binarySearchSmallBoolSmallArrayG (smallArrayt *self, smallBoolt *value) {
14116 
14117  return(self->f->binarySearchSmallBool(self,value));
14118 }
14119 
14120 ssize_t binarySearchSmallBytesSmallArrayG (smallArrayt *self, smallBytest *value) {
14121 
14122  return(self->f->binarySearchSmallBytes(self,value));
14123 }
14124 
14125 ssize_t binarySearchSmallDoubleSmallArrayG (smallArrayt *self, smallDoublet *value) {
14126 
14127  return(self->f->binarySearchSmallDouble(self,value));
14128 }
14129 
14130 ssize_t binarySearchSmallIntSmallArrayG (smallArrayt *self, smallIntt *value) {
14131 
14132  return(self->f->binarySearchSmallInt(self,value));
14133 }
14134 
14135 ssize_t binarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
14136 
14137  return(self->f->binarySearchSmallJson(self,string));
14138 }
14139 
14140 ssize_t binarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
14141 
14142  return(self->f->binarySearchSmallString(self,string));
14143 }
14144 
14145 ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container) {
14146 
14147  return(self->f->binarySearchSmallContainer(self,container));
14148 }
14149 
14150 smallArrayt* uniqSmallArrayG(smallArrayt *self, int dum UNUSED) {
14151 
14152  return(self->f->uniq(self));
14153 }
14154 
14155 bool icHasSmallArrayG (smallArrayt *self, baset *value) {
14156 
14157  return(self->f->icHas(self, value));
14158 }
14159 
14160 bool icHasSSmallArrayG (smallArrayt *self, const char *string) {
14161 
14162  return(self->f->icHasS(self,string));
14163 }
14164 
14165 bool icHasCharSmallArrayG(smallArrayt *self, char c) {
14166 
14167  return(self->f->icHasChar(self,c));
14168 }
14169 
14170 bool icHasDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
14171 
14172  return(self->f->icHasDict(self,dict));
14173 }
14174 
14175 bool icHasArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
14176 
14177  return(self->f->icHasArray(self,array));
14178 }
14179 
14180 bool icHasArraycSmallArrayG (smallArrayt *self, char **array) {
14181 
14182  return(self->f->icHasArrayc(self,array));
14183 }
14184 
14185 bool icHasCArraycSmallArrayG (smallArrayt *self, const char **array) {
14186 
14187  return(self->f->icHasCArrayc(self,array));
14188 }
14189 
14190 bool icHasSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
14191 
14192  return(self->f->icHasSmallJson(self,string));
14193 }
14194 
14195 bool icHasSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
14196 
14197  return(self->f->icHasSmallString(self,string));
14198 }
14199 
14200 ssize_t icIndexOfSmallArrayG (smallArrayt *self, baset *value) {
14201 
14202  return(self->f->icIndexOf(self, value));
14203 }
14204 
14205 ssize_t icIndexOfSSmallArrayG (smallArrayt *self, const char *string) {
14206 
14207  return(self->f->icIndexOfS(self,string));
14208 }
14209 
14210 ssize_t icIndexOfCharSmallArrayG(smallArrayt *self, char c) {
14211 
14212  return(self->f->icIndexOfChar(self,c));
14213 }
14214 
14215 ssize_t icIndexOfDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
14216 
14217  return(self->f->icIndexOfDict(self,dict));
14218 }
14219 
14220 ssize_t icIndexOfArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
14221 
14222  return(self->f->icIndexOfArray(self,array));
14223 }
14224 
14225 ssize_t icIndexOfArraycSmallArrayG (smallArrayt *self, char **array) {
14226 
14227  return(self->f->icIndexOfArrayc(self,array));
14228 }
14229 
14230 ssize_t icIndexOfCArraycSmallArrayG (smallArrayt *self, const char **array) {
14231 
14232  return(self->f->icIndexOfCArrayc(self,array));
14233 }
14234 
14235 ssize_t icIndexOfSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
14236 
14237  return(self->f->icIndexOfSmallJson(self,string));
14238 }
14239 
14240 ssize_t icIndexOfSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
14241 
14242  return(self->f->icIndexOfSmallString(self,string));
14243 }
14244 
14245 ssize_t icBinarySearchSmallArrayG (smallArrayt *self, baset *value) {
14246 
14247  return(self->f->icBinarySearch(self, value));
14248 }
14249 
14250 ssize_t icBinarySearchSSmallArrayG (smallArrayt *self, const char *string) {
14251 
14252  return(self->f->icBinarySearchS(self,string));
14253 }
14254 
14255 ssize_t icBinarySearchCharSmallArrayG(smallArrayt *self, char c) {
14256 
14257  return(self->f->icBinarySearchChar(self,c));
14258 }
14259 
14260 ssize_t icBinarySearchDictSmallArrayG (smallArrayt *self, smallDictt *dict) {
14261 
14262  return(self->f->icBinarySearchDict(self,dict));
14263 }
14264 
14265 ssize_t icBinarySearchArraySmallArrayG (smallArrayt *self, smallArrayt *array) {
14266 
14267  return(self->f->icBinarySearchArray(self,array));
14268 }
14269 
14270 ssize_t icBinarySearchArraycSmallArrayG (smallArrayt *self, char **array) {
14271 
14272  return(self->f->icBinarySearchArrayc(self,array));
14273 }
14274 
14275 ssize_t icBinarySearchCArraycSmallArrayG (smallArrayt *self, const char **array) {
14276 
14277  return(self->f->icBinarySearchCArrayc(self,array));
14278 }
14279 
14280 ssize_t icBinarySearchSmallJsonSmallArrayG (smallArrayt *self, smallJsont *string) {
14281 
14282  return(self->f->icBinarySearchSmallJson(self,string));
14283 }
14284 
14285 ssize_t icBinarySearchSmallStringSmallArrayG (smallArrayt *self, smallStringt *string) {
14286 
14287  return(self->f->icBinarySearchSmallString(self,string));
14288 }
14289 
14290 smallArrayt* icUniqSmallArrayG(smallArrayt *self, int dum UNUSED) {
14291 
14292  return(self->f->icUniq(self));
14293 }
14294 
14295 smallArrayt* compactSmallArrayG (smallArrayt *self) {
14296 
14297  return(self->f->compact(self));
14298 }
14299 
14300 smallArrayt* emptySmallArrayG (smallArrayt *self) {
14301 
14302  return(self->f->empty(self));
14303 }
14304 
14305 bool isEmptySmallArrayG (smallArrayt *self) {
14306 
14307  return(self->f->isEmpty(self));
14308 }
14309 
14310 bool isBlankSmallArrayG (smallArrayt *self) {
14311 
14312  return(self->f->isBlank(self));
14313 }
14314 
14315 smallStringt* joinSmallArrayG(smallArrayt *self, const char* delim) {
14316 
14317  return(self->f->join(self, delim));
14318 }
14319 
14320 smallStringt* joinCharSmallArrayG(smallArrayt *self, char c) {
14321 
14322  return(self->f->joinChar(self,c));
14323 }
14324 
14325 smallStringt* joinSmallJsonSmallArrayG (smallArrayt *self, smallJsont* delim) {
14326 
14327  return(self->f->joinSmallJson(self,delim));
14328 }
14329 
14330 smallStringt* joinSmallStringSmallArrayG(smallArrayt *self, smallStringt* delim) {
14331 
14332  return(self->f->joinSmallString(self,delim));
14333 }
14334 
14335 char* joinSSmallArrayG(smallArrayt *self, const char* delim) {
14336 
14337  return(self->f->joinS(self,delim));
14338 }
14339 
14340 char* joinCharSSmallArrayG(smallArrayt *self, char c) {
14341 
14342  return(self->f->joinCharS(self,c));
14343 }
14344 
14345 char* joinSmallJsonSSmallArrayG (smallArrayt *self, smallJsont* delim) {
14346 
14347  return(self->f->joinSmallJsonS(self,delim));
14348 }
14349 
14350 char* joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt* delim) {
14351 
14352  return(self->f->joinSmallStringS(self,delim));
14353 }
14354 
14355 smallArrayt* zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2) {
14356 
14357  return(self->f->zip(self,array1,array2));
14358 }
14359 
14360 smallArrayt* zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2) {
14361 
14362  return(self->f->zipSmallJson(self,array1,array2));
14363 }
14364 
14365 smallArrayt* zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2) {
14366 
14367  return(self->f->zipSmallJsonSmallArray(self,array1,array2));
14368 }
14369 
14370 smallArrayt* zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2) {
14371 
14372  return(self->f->zipSmallJsonSmallJson(self,array1,array2));
14373 }
14374 
14375 smallArrayt* zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2) {
14376 
14377  return(self->f->zipSmallJsonChar(self,array1,array2));
14378 }
14379 
14380 smallArrayt* zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2) {
14381 
14382  return(self->f->zipSmallJsonCChar(self,array1,array2));
14383 }
14384 
14385 smallArrayt* zipArraySmallArrayG(smallArrayt *self, char** array1, smallArrayt *array2) {
14386 
14387  return(self->f->zipArray(self,array1,array2));
14388 }
14389 
14390 smallArrayt* zipCArraySmallArrayG(smallArrayt *self, const char** array1, smallArrayt *array2) {
14391 
14392  return(self->f->zipCArray(self,array1,array2));
14393 }
14394 
14395 smallArrayt* zipArraySmallJsonSmallArrayG(smallArrayt *self, char** array1, smallJsont *array2) {
14396 
14397  return(self->f->zipArraySmallJson(self,array1,array2));
14398 }
14399 
14400 smallArrayt* zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char** array1, smallJsont *array2) {
14401 
14402  return(self->f->zipCArraySmallJson(self,array1,array2));
14403 }
14404 
14405 smallArrayt* zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char** array2) {
14406 
14407  return(self->f->zipChar(self,array1,array2));
14408 }
14409 
14410 smallArrayt* zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char** array2) {
14411 
14412  return(self->f->zipCChar(self,array1,array2));
14413 }
14414 
14415 smallArrayt* zipArrayCharSmallArrayG(smallArrayt *self, char** array1, char** array2) {
14416 
14417  return(self->f->zipArrayChar(self,array1,array2));
14418 }
14419 
14420 smallArrayt* zipArrayCCharSmallArrayG(smallArrayt *self, char** array1, const char** array2) {
14421 
14422  return(self->f->zipArrayCChar(self,array1,array2));
14423 }
14424 
14425 smallArrayt* zipCArrayCharSmallArrayG(smallArrayt *self, const char** array1, char** array2) {
14426 
14427  return(self->f->zipCArrayChar(self,array1,array2));
14428 }
14429 
14430 smallArrayt* zipCArrayCCharSmallArrayG(smallArrayt *self, const char** array1, const char** array2) {
14431 
14432  return(self->f->zipCArrayCChar(self,array1,array2));
14433 }
14434 
14435 void logSmallArrayG(smallArrayt *self) {
14436 
14437  self->f->log(self);
14438 }
14439 
14440 smallArrayt* readTextSmallArrayG (smallArrayt *self, const char *filePath) {
14441 
14442  return(self->f->readText(self, filePath));
14443 }
14444 
14445 smallArrayt* readTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath) {
14446 
14447  return(self->f->readTextSmallJson(self,filePath));
14448 }
14449 
14450 smallArrayt* readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) {
14451 
14452  return(self->f->readTextSmallString(self,filePath));
14453 }
14454 
14455 smallArrayt* readStreamSmallArrayG (smallArrayt *self, FILE *fp) {
14456 
14457  return(self->f->readStream(self, fp));
14458 }
14459 
14460 bool writeTextSmallArrayG (smallArrayt *self, const char *filePath) {
14461 
14462  return(self->f->writeText(self, filePath));
14463 }
14464 
14465 bool writeTextSmallJsonSmallArrayG (smallArrayt *self, smallJsont *filePath) {
14466 
14467  return(self->f->writeTextSmallJson(self,filePath));
14468 }
14469 
14470 bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) {
14471 
14472  return(self->f->writeTextSmallString(self,filePath));
14473 }
14474 
14475 bool writeStreamSmallArrayG (smallArrayt *self, FILE *fp) {
14476 
14477  return(self->f->writeStream(self, fp));
14478 }
14479 
14480 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath) {
14481 
14482  return(self->f->appendText(self,filePath));
14483 }
14484 
14485 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath) {
14486 
14487  return(self->f->appendTextSmallString(self,filePath));
14488 }
14489 
14490 smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index) {
14491 
14492  return(self->f->typeSmallString(self,index));
14493 }
14494 
14495 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self) {
14496 
14497  return(self->f->typeSmallStrings(self));
14498 }
14499 
getAtUintSmallArrayG
uint64_t getAtUintSmallArrayG(smallArrayt *self, uint64_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13029
writeTextSmallJsonSmallArray
internal bool writeTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath)
Definition: libsheepyCSmallArray.c:12118
addSmallArray
internal smallArrayt * addSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3920
cropElemDictSmallArrayG
smallDictt * cropElemDictSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13542
getAtUndefinedSmallArray
internal undefinedt * getAtUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6888
dequeueUint32SmallArrayG
uint32_t dequeueUint32SmallArrayG(smallArrayt *self, uint32_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12916
listFreeS
void listFreeS(char **list)
list Free String
Definition: libsheepy.c:50780
icHasCharSmallArray
internal bool icHasCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:10042
pushNFreeDictSmallArray
internal smallArrayt * pushNFreeDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:2102
cleanUpSmallArrayDisposeG
void cleanUpSmallArrayDisposeG(smallArrayt *val)
Definition: libsheepyCSmallArray.c:1483
icIndexOfArraycSmallArray
internal ssize_t icIndexOfArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:10246
icHasSSmallArray
internal bool icHasSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:10029
prependNFreeSmallJsonSmallArray
internal smallArrayt * prependNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:3136
injectArraySmallArray
internal smallArrayt * injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject)
Definition: libsheepyCSmallArray.c:5477
dequeueArraySmallArray
internal smallArrayt * dequeueArraySmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3357
prependSmallBoolSmallArrayG
smallArrayt * prependSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:12778
hasSmallBoolSmallArrayG
bool hasSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:13935
getAtNDupInt32SmallArrayG
int32_t getAtNDupInt32SmallArrayG(smallArrayt *self, int32_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13130
s
char * s
Definition: libsheepyObjectTest.c:27
getAtBoolSmallArrayG
bool getAtBoolSmallArrayG(smallArrayt *self, bool retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:12989
charToS
#define charToS(dst, c)
Definition: libsheepy.h:1862
injectNFreeArraycSmallArrayG
smallArrayt * injectNFreeArraycSmallArrayG(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:13745
appendCArraySmallArray
internal smallArrayt * appendCArraySmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:3855
prependNFreeSmallBytesSmallArray
internal smallArrayt * prependNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:3109
so
smallt * so
Definition: libsheepyObjectTest.c:2264
setAtSmallDoubleSmallArrayG
smallArrayt * setAtSmallDoubleSmallArrayG(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:13277
icHasArraycSmallArrayG
bool icHasArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:14180
cropElemDoubleSmallArray
internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4189
indexOfSmallContainerSmallArray
internal ssize_t indexOfSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED)
Definition: libsheepyCSmallArray.c:9209
getAtNDupUintSmallArrayG
uint64_t getAtNDupUintSmallArrayG(smallArrayt *self, uint64_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13135
sArrayReverseTiny
int sArrayReverseTiny(sArrayt *array)
reverse element order
Definition: libsheepySmall.c:1782
prependSSmallArray
internal smallArrayt * prependSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:2811
O
#define O(obj, method)
O calls an object method without parameters O(obj,toString) calls the toString method in the obj obje...
Definition: libsheepyObject.h:395
icIndexOfCharSmallArray
internal ssize_t icIndexOfCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:10174
getAtSSmallArrayG
char * getAtSSmallArrayG(smallArrayt *self, char *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13049
len
size_t len
Definition: libsheepyObjectTest.c:108
cropSmallArrayG
smallArrayt * cropSmallArrayG(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:13492
insertSmallJsonSmallArrayG
smallArrayt * insertSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert)
Definition: libsheepyCSmallArray.c:13602
mirrorSmallArray
internal smallArrayt * mirrorSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1666
eqS
bool eqS(const char *string1, const char *string2)
string Equal compare string1 to string2
Definition: libsheepy.c:9067
dequeueSSmallArray
internal char * dequeueSSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3309
icBinarySearchArraySmallArrayG
ssize_t icBinarySearchArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:14265
icHasSmallJsonSmallArray
internal bool icHasSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:10100
cropElemDictSmallArray
internal smallDictt * cropElemDictSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4442
isBlankS
bool isBlankS(const char *string)
is Blank String
Definition: libsheepy.c:50246
injectSmallBytesSmallArrayG
smallArrayt * injectSmallBytesSmallArrayG(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:13689
sliceSmallArray
internal smallArrayt * sliceSmallArray(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:3952
cropElemSmallArrayG
baset * cropElemSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13497
hasSmallBoolSmallArray
internal bool hasSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:8644
initiateSmallArray
void initiateSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:931
zipCArrayCharSmallArrayG
smallArrayt * zipCArrayCharSmallArrayG(smallArrayt *self, const char **array1, char **array2)
Definition: libsheepyCSmallArray.c:14425
getTopSO
#define getTopSO(self)
Definition: libsheepyObject.h:8850
injectSmallBoolSmallArray
internal smallArrayt * injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject)
Definition: libsheepyCSmallArray.c:5715
getAtNDupSmallBytesSmallArray
internal smallBytest * getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7487
getAtNDupSmallIntSmallArray
internal smallIntt * getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7531
prependBoolSmallArrayG
smallArrayt * prependBoolSmallArrayG(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:12721
sToString
char * sToString(smallt *obj)
stringify object
Definition: libsheepySmall.c:654
MIN
#define MIN(a, b)
Definition: libsheepy.h:467
prependSmallIntSmallArrayG
smallArrayt * prependSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:12793
allocSmallArrayG
smallArrayt * allocSmallArrayG(smallArrayt *self UNUSED)
Definition: libsheepyCSmallArray.c:12413
insertSmallArray
internal smallArrayt * insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert)
Definition: libsheepyCSmallArray.c:4878
icBinarySearchSmallJsonSmallArrayG
ssize_t icBinarySearchSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:14280
sortFSmallArrayG
smallArrayt * sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction)
Definition: libsheepyCSmallArray.c:13810
getAtSmallBytesSmallArray
internal smallBytest * getAtSmallBytesSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7132
pushNFreeSmallStringSmallArrayG
smallArrayt * pushNFreeSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:12603
zipArrayCCharSmallArray
internal smallArrayt * zipArrayCCharSmallArray(smallArrayt *self, char **array1, const char **array2)
Definition: libsheepyCSmallArray.c:11912
hasArraycSmallArrayG
bool hasArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:13925
setAtSmallJsonSmallArray
internal smallArrayt * setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value)
Definition: libsheepyCSmallArray.c:8012
pushSmallDoubleSmallArray
internal smallArrayt * pushSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:1976
prependNFreeUndefinedSmallArray
internal smallArrayt * prependNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u)
Definition: libsheepyCSmallArray.c:3055
pushNFreeSmallBoolSmallArrayG
smallArrayt * pushNFreeSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:12578
popSmallBytesSmallArrayG
smallBytest * popSmallBytesSmallArrayG(smallArrayt *self, smallBytest *retType UNUSED)
Definition: libsheepyCSmallArray.c:12675
popDictSmallArray
internal smallDictt * popDictSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2421
free
free(s)
finalizeSmallArray
void finalizeSmallArray(void)
Definition: libsheepyCSmallArray.c:1518
prependNFreeSmallJsonSmallArrayG
smallArrayt * prependNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:12864
allocSStringTiny
sStringt * allocSStringTiny(const char *data)
allocate a small string
Definition: libsheepySmall.c:308
injectIntSmallArray
internal smallArrayt * injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject)
Definition: libsheepyCSmallArray.c:5268
ssGet
#define ssGet(obj)
get a pointer to the string in the smallString object
Definition: libsheepyObject.h:9808
injectNFreeUndefinedSmallArrayG
smallArrayt * injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value)
Definition: libsheepyCSmallArray.c:13725
indexOfSmallStringSmallArray
internal ssize_t indexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:9180
fromArraySmallArrayG
smallArrayt * fromArraySmallArrayG(smallArrayt *self, char **array, size_t size)
Definition: libsheepyCSmallArray.c:12425
dequeueSmallStringSmallArrayG
smallStringt * dequeueSmallStringSmallArrayG(smallArrayt *self, smallStringt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12961
cleanUpSmallArrayFreeG
void cleanUpSmallArrayFreeG(smallArrayt **val)
Definition: libsheepyCSmallArray.c:1473
prependSmallArrayG
smallArrayt * prependSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:12711
sArraySetP
void sArraySetP(sArrayt *array, uint32_t index, smallt *value)
set value at index
Definition: libsheepySmall.c:1745
pushBoolSmallArrayG
smallArrayt * pushBoolSmallArrayG(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:12455
pushNFreeSmallStringSmallArray
internal smallArrayt * pushNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:2174
popUndefinedSmallArrayG
undefinedt * popUndefinedSmallArrayG(smallArrayt *self, undefinedt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12620
rangeDown
#define rangeDown(index, maxCount)
range down loop, index is ssize_t
Definition: libsheepy.h:2786
B
smallBytest * B
Definition: libsheepyObjectTest.c:1026
toStringListCSGF
char * toStringListCSGF(const char **object)
Definition: libsheepyObject.c:1294
joinSmallStringSmallArray
internal smallStringt * joinSmallStringSmallArray(smallArrayt *self, smallStringt *delim)
Definition: libsheepyCSmallArray.c:11383
getAtNDupVoidSmallArray
internal void * getAtNDupVoidSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7606
allocSInt
sIntt * allocSInt(int64_t value)
allocate a small int
Definition: libsheepySmall.c:291
joinSmallStringSSmallArrayG
char * joinSmallStringSSmallArrayG(smallArrayt *self, smallStringt *delim)
Definition: libsheepyCSmallArray.c:14350
hasSmallJsonSmallArrayG
bool hasSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:13955
sc
sContainert * sc
Definition: libsheepyObjectTest.c:2283
zipSmallJsonSmallArrayG
smallArrayt * zipSmallJsonSmallArrayG(smallArrayt *self, smallArrayt *array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:14360
indexOfDictSmallArray
internal ssize_t indexOfDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:8897
indexOfSmallIntSmallArray
internal ssize_t indexOfSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:9097
equalSmallArrayArrayG
bool equalSmallArrayArrayG(smallArrayt *self, char **p2)
Definition: libsheepyCSmallArray.c:13830
removeElemSmallArrayG
smallArrayt * removeElemSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13800
binarySearchSmallStringSmallArray
internal ssize_t binarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:9841
prependSmallArray
internal smallArrayt * prependSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:2756
icSortSCmp
internal int icSortSCmp(const void *a, const void *b)
Definition: libsheepyCSmallArray.c:6301
enumerateSmallArray
#define enumerateSmallArray(array, element, index)
enumerate non NULL elements in list skip deleted elements
Definition: libsheepyCSmallArray.h:2444
zipCArraySmallArray
internal smallArrayt * zipCArraySmallArray(smallArrayt *self, const char **array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:11685
hasDictSmallArray
internal bool hasDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:8584
isEDictSmallArray
internal bool isEDictSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12304
readTextSmallStringSmallArray
internal smallArrayt * readTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:12052
binarySearchArraycSmallArrayG
ssize_t binarySearchArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:14105
RST
#define RST
reset for color function
Definition: libsheepy.h:763
getAtIntPSmallArray
internal int64_t * getAtIntPSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6970
addSmallArrayG
smallArrayt * addSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13482
getAtNDupBoolSmallArray
internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7337
getAtNDupSmallDoubleSmallArrayG
smallDoublet * getAtNDupSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13170
typeStringsSmallArray
internal const char ** typeStringsSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12243
setAtNFreeSmallArray
internal smallArrayt * setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:8097
icBinarySearchSSmallArray
internal ssize_t icBinarySearchSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:10428
getAtNDupSmallArray
baset * getAtNDupSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7287
injectSmallContainerSmallArray
internal smallArrayt * injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject)
Definition: libsheepyCSmallArray.c:5824
sArrayDequeueTiny
smallt * sArrayDequeueTiny(sArrayt *array)
dequeue object from array
Definition: libsheepySmall.c:1674
zipCArraySmallJsonSmallArray
internal smallArrayt * zipCArraySmallJsonSmallArray(smallArrayt *self, const char **array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:11746
emptySmallArrayG
smallArrayt * emptySmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14300
appendNSmashArraySmallArrayG
smallArrayt * appendNSmashArraySmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:13444
pushUndefinedSmallArray
internal smallArrayt * pushUndefinedSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1799
sArraySetShortTiny
void sArraySetShortTiny(sArrayt *array, uint32_t index, smallt *value)
set value at index
Definition: libsheepySmall.c:1729
areAllEDictSmallArray
internal bool areAllEDictSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12376
pushDictSmallArray
internal smallArrayt * pushDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:1858
freeSmallArrayG
void freeSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12423
binarySearchDoubleSmallArray
internal ssize_t binarySearchDoubleSmallArray(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:9324
prependNFreeSSmallArrayG
smallArrayt * prependNFreeSSmallArrayG(smallArrayt *self, char *string)
Definition: libsheepyCSmallArray.c:12824
allocSmallContainer
smallContainert * allocSmallContainer(void *data)
Definition: libsheepyCSmallContainer.c:142
indexOfIntSmallArrayG
ssize_t indexOfIntSmallArrayG(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:13990
injectUndefinedSmallArrayG
smallArrayt * injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED)
Definition: libsheepyCSmallArray.c:13622
reverseSmallArray
internal smallArrayt * reverseSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3714
getAtSmallBoolSmallArrayG
smallBoolt * getAtSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13064
setAtDictSmallArray
internal smallArrayt * setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:7774
cropElemIntSmallArray
internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4231
getsoSmallArray
internal sArrayt * getsoSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1655
u64
#define u64
Definition: libsheepy.h:448
prependSmallContainerSmallArrayG
smallArrayt * prependSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:12808
setAtSmallBoolSmallArray
internal smallArrayt * setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:7904
getAtNDupSmallBytesSmallArrayG
smallBytest * getAtNDupSmallBytesSmallArrayG(smallArrayt *self, smallBytest *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13165
setAtSmallBoolSmallArrayG
smallArrayt * setAtSmallBoolSmallArrayG(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:13267
equalSmallArrayCArray
internal bool equalSmallArrayCArray(smallArrayt *self, const char **p2)
Definition: libsheepyCSmallArray.c:6593
zipSmallJsonSmallArray
internal smallArrayt * zipSmallJsonSmallArray(smallArrayt *self, smallArrayt *array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:11505
joinSmallJsonSSmallArrayG
char * joinSmallJsonSSmallArrayG(smallArrayt *self, smallJsont *delim)
Definition: libsheepyCSmallArray.c:14345
setPAtNFreeSmallJsonSmallArrayG
smallArrayt * setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json)
Definition: libsheepyCSmallArray.c:13399
icBinarySearchArraySmallArray
internal ssize_t icBinarySearchArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:10517
popSmallDoubleSmallArray
internal smallDoublet * popSmallDoubleSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2541
setAtArraycSmallArrayG
smallArrayt * setAtArraycSmallArrayG(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:13245
zipSmallJsonCharSmallArray
internal smallArrayt * zipSmallJsonCharSmallArray(smallArrayt *self, smallJsont *array1, char **array2)
Definition: libsheepyCSmallArray.c:11600
smallArray::f
smallArrayFunctionst * f
Definition: libsheepyCSmallArray.h:1894
getAtIntSmallArrayG
int64_t getAtIntSmallArrayG(smallArrayt *self, int64_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13009
injectNFreeSmallDoubleSmallArrayG
smallArrayt * injectNFreeSmallDoubleSmallArrayG(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:13760
pushNFreeArraySmallArrayG
smallArrayt * pushNFreeArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:12568
getAtNDupUndefinedSmallArrayG
undefinedt * getAtNDupUndefinedSmallArrayG(smallArrayt *self, undefinedt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13110
injectSmallDoubleSmallArrayG
smallArrayt * injectSmallDoubleSmallArrayG(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:13694
injectCharSmallArrayG
smallArrayt * injectCharSmallArrayG(smallArrayt *self, int64_t index, char c)
Definition: libsheepyCSmallArray.c:13647
getAtNDupIntSmallArrayG
int64_t getAtNDupIntSmallArrayG(smallArrayt *self, int64_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13125
hasSmallIntSmallArray
internal bool hasSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:8695
getAtSmallJsonSmallArrayG
smallJsont * getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13084
sArrayDelRangeTiny
void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end)
delete range and shift elements
Definition: libsheepySmall.c:1826
sArrayDelTiny
void sArrayDelTiny(sArrayt *array, uint32_t index)
delete element at index
Definition: libsheepySmall.c:1806
binarySearchSSmallArray
internal ssize_t binarySearchSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:9392
setAtNFreeSmallStringSmallArrayG
smallArrayt * setAtNFreeSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13358
cropElemSmallJsonSmallArrayG
smallJsont * cropElemSmallJsonSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13572
setAtNFreeSmallJsonSmallArray
internal smallArrayt * setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value)
Definition: libsheepyCSmallArray.c:8206
isOSmallInt
#define isOSmallInt(obj)
test if obj type is smallInt
Definition: libsheepyObject.h:263
isEmptySmallArrayG
bool isEmptySmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14305
joinCharSmallArray
internal smallStringt * joinCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:11358
hasSmallBytesSmallArrayG
bool hasSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:13940
i
smallt * i
Definition: libsheepyObjectTest.c:344
getAtVoidSmallArrayG
void * getAtVoidSmallArrayG(smallArrayt *self, void *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13094
appendSmallJsonSmallArrayG
smallArrayt * appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:13424
createSAF
smallArrayt * createSAF(const char *paramType,...)
create String Array Function
Definition: libsheepyCSmallArray.c:1493
pushSmallArray
internal smallArrayt * pushSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:1785
setPAtSmallJsonSmallArray
internal smallArrayt * setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json)
Definition: libsheepyCSmallArray.c:8292
iterStepSmallArray
internal int64_t iterStepSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11315
createAllocateSmallBytes
createAllocateSmallBytes(obj2)
getAtNDupSmallJsonSmallArrayG
smallJsont * getAtNDupSmallJsonSmallArrayG(smallArrayt *self, smallJsont *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13180
icEqS
bool icEqS(const char *string1, const char *string2)
ignore case string Equal compare string1 to string2
Definition: libsheepy.c:9283
trimS
char * trimS(const char *string)
trim String duplicate string
Definition: libsheepy.c:11245
prependSmallIntSmallArray
internal smallArrayt * prependSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:2963
pushIntSmallArray
internal smallArrayt * pushIntSmallArray(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:1829
dequeueInt32SmallArray
internal int32_t dequeueInt32SmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3273
sArrayt
array
Definition: libsheepySmall.h:158
cropElemSmallContainerSmallArrayG
smallContainert * cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13587
equalSmallArrayArray
internal bool equalSmallArrayArray(smallArrayt *self, char **p2)
Definition: libsheepyCSmallArray.c:6563
popSmallStringSmallArray
internal smallStringt * popSmallStringSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2639
indexOfCharSmallArray
internal ssize_t indexOfCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:8891
areAllEContainerSmallArray
internal bool areAllEContainerSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12371
freeSmallArray
internal void freeSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1527
pushCharSmallArray
internal smallArrayt * pushCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:1852
binarySearchSmallContainerSmallArray
internal ssize_t binarySearchSmallContainerSmallArray(smallArrayt *self UNUSED, smallContainert *container UNUSED)
Definition: libsheepyCSmallArray.c:9878
injectSmallStringSmallArray
internal smallArrayt * injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject)
Definition: libsheepyCSmallArray.c:5807
icEqualSmallArrayBaseG
bool icEqualSmallArrayBaseG(smallArrayt *self, baset *p2)
Definition: libsheepyCSmallArray.c:13865
injectNFreeSmallBoolSmallArray
internal smallArrayt * injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject)
Definition: libsheepyCSmallArray.c:5961
prependSmallJsonSmallArrayG
smallArrayt * prependSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:12798
catSmallArray
internal smallArrayt * catSmallArray(smallArrayt *self,...)
Definition: libsheepyCSmallArray.c:3730
binarySearchSmallBytesSmallArray
internal ssize_t binarySearchSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:9665
pushSSmallArray
internal smallArrayt * pushSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:1839
typeSmallStringsSmallArrayG
smallArrayt * typeSmallStringsSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14495
injectNFreeArraySmallArray
internal smallArrayt * injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject)
Definition: libsheepyCSmallArray.c:5943
pFuncError
#define pFuncError
print function name and system error
Definition: libsheepy.h:306
writeTextSmallStringSmallArray
internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:12137
setPAtDictSmallArrayG
smallArrayt * setPAtDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13369
iterIndexSmallArray
internal ssize_t iterIndexSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11310
isEIntSmallArray
internal bool isEIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12314
hasSmallDoubleSmallArrayG
bool hasSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:13945
popArraySmallArray
internal smallArrayt * popArraySmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2451
injectNFreeDictSmallArray
internal smallArrayt * injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject)
Definition: libsheepyCSmallArray.c:5934
writeTextSmallArray
internal bool writeTextSmallArray(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:12090
areAllEUndefinedSmallArray
internal bool areAllEUndefinedSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12361
prependSmallDoubleSmallArray
internal smallArrayt * prependSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:2946
emptySmallArray
internal smallArrayt * emptySmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:10982
getAtNDupBoolSmallArrayG
bool getAtNDupBoolSmallArrayG(smallArrayt *self, bool retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13115
dequeueInt32SmallArrayG
int32_t dequeueInt32SmallArrayG(smallArrayt *self, int32_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12906
dequeueBoolSmallArray
internal bool dequeueBoolSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3237
lenO
#define lenO(self)
Definition: libsheepyObject.h:5156
zipCharSmallArray
internal smallArrayt * zipCharSmallArray(smallArrayt *self, smallArrayt *array1, char **array2)
Definition: libsheepyCSmallArray.c:11770
injectNFreeDictSmallArrayG
smallArrayt * injectNFreeDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13735
smallt
base class for the small objects all small objects have a type
Definition: libsheepySmall.h:67
indexOfCArraycSmallArrayG
ssize_t indexOfCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:14020
reverseSmallArrayG
smallArrayt * reverseSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:13414
base::f
baseFunctionst * f
Definition: libsheepyObject.h:9599
prependSmallBoolSmallArray
internal smallArrayt * prependSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:2912
joinCharSSmallArray
internal char * joinCharSSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:11434
injectNFreeSmallContainerSmallArray
internal smallArrayt * injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject)
Definition: libsheepyCSmallArray.c:6015
d
smallDictt * d
Definition: libsheepyObjectTest.c:2328
readTextSmallStringSmallArrayG
smallArrayt * readTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:14450
enumerateSmallArrayF
internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem)
Definition: libsheepyCSmallArray.c:11080
indexOfSmallStringSmallArrayG
ssize_t indexOfSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:14050
getAtDoubleSmallArrayG
double getAtDoubleSmallArrayG(smallArrayt *self, double retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:12999
hasSmallIntSmallArrayG
bool hasSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:13950
getAtSmallDoubleSmallArrayG
smallDoublet * getAtSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13074
hasArraySmallArrayG
bool hasArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13920
zipArrayCharSmallArray
internal smallArrayt * zipArrayCharSmallArray(smallArrayt *self, char **array1, char **array2)
Definition: libsheepyCSmallArray.c:11846
isEStringSmallArray
internal bool isEStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12319
zipCCharSmallArrayG
smallArrayt * zipCCharSmallArrayG(smallArrayt *self, smallArrayt *array1, const char **array2)
Definition: libsheepyCSmallArray.c:14410
setAtSmallBytesSmallArray
internal smallArrayt * setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:7931
forEachSArray
#define forEachSArray(array, element)
Definition: libsheepySmall.h:268
createAllocateSmallDict
#define createAllocateSmallDict(obj)
Definition: libsheepyCSmallDict.h:1087
prependNFreeSmallBoolSmallArrayG
smallArrayt * prependNFreeSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:12844
data
char data[7]
Definition: libsheepy.c:19690
allocSBytes
sBytest * allocSBytes(void)
allocate a small bytes object
Definition: libsheepySmall.c:359
appendArraySmallArray
internal smallArrayt * appendArraySmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:3835
appendArraySmallArrayG
smallArrayt * appendArraySmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:13439
getAtDictSmallArray
internal smallDictt * getAtDictSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7066
binarySearchArraycSmallArray
internal ssize_t binarySearchArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:9532
icBinarySearchSmallArray
internal ssize_t icBinarySearchSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:10390
forEachCCharP
#define forEachCCharP(list, element)
forEach for const char** lists
Definition: libsheepy.h:2985
getAtNDupSmallDoubleSmallArray
internal smallDoublet * getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7509
cropElemSmallDoubleSmallArrayG
smallDoublet * cropElemSmallDoubleSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13562
typeStringSmallArray
internal const char * typeStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12206
cleanUpSmallArrayTerminateG
void cleanUpSmallArrayTerminateG(smallArrayt **val)
Definition: libsheepyCSmallArray.c:1463
getAtNDupDictSmallArray
internal smallDictt * getAtNDupDictSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7421
indexOfSmallBoolSmallArrayG
ssize_t indexOfSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:14025
hasSmallBytesSmallArray
internal bool hasSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:8661
cropElemUintSmallArrayG
uint64_t cropElemUintSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13527
cropElemSmallIntSmallArray
internal smallIntt * cropElemSmallIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4627
pushNFreeSSmallArrayG
smallArrayt * pushNFreeSSmallArrayG(smallArrayt *self, char *string)
Definition: libsheepyCSmallArray.c:12558
b
baset * b
Definition: libsheepyObjectTest.c:402
pushSmallDoubleSmallArrayG
smallArrayt * pushSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:12522
dequeueUintSmallArrayG
uint64_t dequeueUintSmallArrayG(smallArrayt *self, uint64_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12911
getAtNDupUintSmallArray
internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7385
joinCharSmallArrayG
smallStringt * joinCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14320
indexOfSmallBoolSmallArray
internal ssize_t indexOfSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:9021
insertSmallJsonSmallArray
internal smallArrayt * insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert)
Definition: libsheepyCSmallArray.c:4961
setAtCharSmallArray
internal smallArrayt * setAtCharSmallArray(smallArrayt *self, int64_t index, char c)
Definition: libsheepyCSmallArray.c:7768
isError
#define isError(assigned, left)
is Assigment Error catch error when assigned is false, 0 or NULL after being assigned with left ...
Definition: libsheepy.h:386
cropElemBoolSmallArrayG
bool cropElemBoolSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13507
injectCharSmallArray
internal smallArrayt * injectCharSmallArray(smallArrayt *self, int64_t index, char c)
Definition: libsheepyCSmallArray.c:5397
binarySearchSmallDoubleSmallArray
internal ssize_t binarySearchSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:9705
binarySearchUndefinedSmallArrayG
ssize_t binarySearchUndefinedSmallArrayG(smallArrayt *self, undefinedt *value)
Definition: libsheepyCSmallArray.c:14065
sBytest
small bytes
Definition: libsheepySmall.h:181
setPAtNFreeSmallStringSmallArrayG
smallArrayt * setPAtNFreeSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13404
setAtNFreeSmallDoubleSmallArrayG
smallArrayt * setAtNFreeSmallDoubleSmallArrayG(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:13343
setAtNFreeArraycSmallArray
internal smallArrayt * setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:8161
typeSmallArray
internal char typeSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12216
o2
smallJsont * o2
Definition: libsheepyObjectTest.c:403
hasSmallJsonSmallArray
internal bool hasSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:8712
icHasCArraycSmallArray
internal bool icHasCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:10087
getAtNDupSmallStringSmallArrayG
smallStringt * getAtNDupSmallStringSmallArrayG(smallArrayt *self, smallStringt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13185
setAtDoubleSmallArray
internal smallArrayt * setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value)
Definition: libsheepyCSmallArray.c:7706
terminateSmallArray
internal void terminateSmallArray(smallArrayt **self)
Definition: libsheepyCSmallArray.c:1533
indexOfIntSmallArray
internal ssize_t indexOfIntSmallArray(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:8851
cropElemSmallDoubleSmallArray
internal smallDoublet * cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4590
prependNFreeSmallIntSmallArray
internal smallArrayt * prependNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:3127
shiftNSmashSmallArrayG
smallArrayt * shiftNSmashSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13468
allocSmallArray
smallArrayt * allocSmallArray(void)
Definition: libsheepyCSmallArray.c:1440
cropElemUndefinedSmallArrayG
undefinedt * cropElemUndefinedSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13502
pushArraycSmallArrayG
smallArrayt * pushArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:12490
injectSmallBytesSmallArray
internal smallArrayt * injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject)
Definition: libsheepyCSmallArray.c:5732
sStringGetTiny
char * sStringGetTiny(sStringt *string)
get string in a small string object
Definition: libsheepySmall.c:1538
sArrayTypeStrings
const char ** sArrayTypeStrings(sArrayt *obj)
list first level of array types in a list of strings
Definition: libsheepySmall.c:1257
duplicateSmallArrayG
smallArrayt * duplicateSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12418
dequeueSmallDoubleSmallArray
internal smallDoublet * dequeueSmallDoubleSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3465
zipArraySmallArrayG
smallArrayt * zipArraySmallArrayG(smallArrayt *self, char **array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:14385
injectNFreeSmallArray
internal smallArrayt * injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject)
Definition: libsheepyCSmallArray.c:5841
prependArraySmallArray
internal smallArrayt * prependArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:2849
sortSmallArray
internal smallArrayt * sortSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:6243
smallBool::value
sBoolt * value
bool value
Definition: libsheepyCSmallBool.h:229
icBinarySearchSmallStringSmallArray
internal ssize_t icBinarySearchSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:10720
joinSSmallArrayG
char * joinSSmallArrayG(smallArrayt *self, const char *delim)
Definition: libsheepyCSmallArray.c:14335
finalizeRecycleSmallArray
void finalizeRecycleSmallArray(void *arg UNUSED)
Definition: libsheepyCSmallArray.c:1510
popVoidSmallArrayG
void * popVoidSmallArrayG(smallArrayt *self, void *retType UNUSED)
Definition: libsheepyCSmallArray.c:12700
getAtNDupSSmallArray
internal char * getAtNDupSSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7409
setAtNFreeSmallJsonSmallArrayG
smallArrayt * setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value)
Definition: libsheepyCSmallArray.c:13353
cropElemIntSmallArrayG
int64_t cropElemIntSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13517
getAtSmallIntSmallArray
internal smallIntt * getAtSmallIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7176
injectNFreeSmallArrayG
smallArrayt * injectNFreeSmallArrayG(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:13720
pushVoidSmallArrayG
smallArrayt * pushVoidSmallArrayG(smallArrayt *self, void *value)
Definition: libsheepyCSmallArray.c:12500
injectDictSmallArray
internal smallArrayt * injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject)
Definition: libsheepyCSmallArray.c:5403
icIndexOfSSmallArrayG
ssize_t icIndexOfSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:14205
icHasDictSmallArrayG
bool icHasDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:14170
isEContainerSmallArray
internal bool isEContainerSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12299
pStrError
#define pStrError(str)
print string and system error
Definition: libsheepy.h:311
compactSmallArray
internal smallArrayt * compactSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:10889
cropElemSmallArray
internal baset * cropElemSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4061
readTextSmallJsonSmallArrayG
smallArrayt * readTextSmallJsonSmallArrayG(smallArrayt *self, smallJsont *filePath)
Definition: libsheepyCSmallArray.c:14445
indexOfDoubleSmallArrayG
ssize_t indexOfDoubleSmallArrayG(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:13985
icBinarySearchCArraycSmallArrayG
ssize_t icBinarySearchCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:14275
getTopTypeO
#define getTopTypeO(self)
Definition: libsheepyObject.h:8709
popBoolSmallArray
internal bool popBoolSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2337
enumerateS
#define enumerateS(list, element, index)
enumerateS list to acess the element in the loop, use element ;size_t needed to avoid: error: a label...
Definition: libsheepy.h:3037
pushNFreeManySSmallArray
internal smallArrayt * pushNFreeManySSmallArray(smallArrayt *self,...)
Definition: libsheepyCSmallArray.c:2249
injectDoubleSmallArray
internal smallArrayt * injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject)
Definition: libsheepyCSmallArray.c:5205
icIndexOfSmallStringSmallArray
internal ssize_t icIndexOfSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:10361
indexOfCArraycSmallArray
internal ssize_t indexOfCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:8992
pushNFreeSmallBoolSmallArray
internal smallArrayt * pushNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:2129
shiftNSmashSmallJsonSmallArray
internal smallArrayt * shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:3914
isOSmallJson
#define isOSmallJson(obj)
test if obj type is smallJson
Definition: libsheepyObject.h:269
sArrayPushTiny
void sArrayPushTiny(sArrayt **array, smallt *data)
push data to array
Definition: libsheepySmall.c:1569
hasSSmallArray
internal bool hasSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:8565
sIntt
small int
Definition: libsheepySmall.h:128
hasCArraycSmallArrayG
bool hasCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:13930
binarySearchCArraycSmallArray
internal ssize_t binarySearchCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:9579
duplicateSmallArray
internal smallArrayt * duplicateSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1548
icEqualSmallArrayG
bool icEqualSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13845
disposeSmallArray
internal void disposeSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1579
hasUndefinedSmallArrayG
bool hasUndefinedSmallArrayG(smallArrayt *self, undefinedt *value)
Definition: libsheepyCSmallArray.c:13885
isOType
#define isOType(obj, className)
test obj type
Definition: libsheepyObject.h:221
getAtUintPSmallArray
internal uint64_t * getAtUintPSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7018
smallString::f
smallStringFunctionst * f
Definition: libsheepyCSmallString.h:1265
popArraySmallArrayG
smallArrayt * popArraySmallArrayG(smallArrayt *self, smallArrayt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12665
isOSmallContainer
#define isOSmallContainer(obj)
test if obj type is smallContainer
Definition: libsheepyObject.h:245
indexOfSmallDoubleSmallArrayG
ssize_t indexOfSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:14035
dequeueSmallBytesSmallArrayG
smallBytest * dequeueSmallBytesSmallArrayG(smallArrayt *self, smallBytest *retType UNUSED)
Definition: libsheepyCSmallArray.c:12941
array
char * array[]
Definition: libsheepyObjectTest.c:1278
prependNFreeDictSmallArrayG
smallArrayt * prependNFreeDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:12829
isEDoubleSmallArray
internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12309
elif
#define elif
elif definition as alternative to else if
Definition: libsheepy.h:589
icEqualSmallArrayArrayG
bool icEqualSmallArrayArrayG(smallArrayt *self, char **p2)
Definition: libsheepyCSmallArray.c:13855
getAtNDupSmallContainerSmallArray
internal smallContainert * getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7618
binarySearchSmallBytesSmallArrayG
ssize_t binarySearchSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:14120
isOUndefined
#define isOUndefined(obj)
test if obj type is undefined
Definition: libsheepyObject.h:281
zipArraySmallArray
internal smallArrayt * zipArraySmallArray(smallArrayt *self, char **array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:11648
prependNFreeSmallContainerSmallArray
internal smallArrayt * prependNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:3154
sDuplicateTiny
smallt * sDuplicateTiny(smallt *obj)
duplicate small object
Definition: libsheepySmall.c:504
zipSmallJsonSmallArraySmallArray
internal smallArrayt * zipSmallJsonSmallArraySmallArray(smallArrayt *self, smallJsont *array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:11533
smashSmallArray
internal void smashSmallArray(smallArrayt **self)
Definition: libsheepyCSmallArray.c:1593
indexOfArraycSmallArray
internal ssize_t indexOfArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:8963
createAllocateSmallJson
#define createAllocateSmallJson(obj)
Definition: libsheepyCSmallJson.h:3519
lenSmallArrayG
size_t lenSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:13870
typeSmallStringSmallArrayG
smallStringt * typeSmallStringSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:14490
terminateO
#define terminateO(obj)
free buffers and obj itself
Definition: libsheepyObject.h:202
injectNFreeSmallBytesSmallArray
internal smallArrayt * injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject)
Definition: libsheepyCSmallArray.c:5970
appendNSmashSmallJsonSmallArray
internal smallArrayt * appendNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:3825
setAtDoubleSmallArrayG
smallArrayt * setAtDoubleSmallArrayG(smallArrayt *self, int64_t index, double value)
Definition: libsheepyCSmallArray.c:13215
injectSSmallArrayG
smallArrayt * injectSSmallArrayG(smallArrayt *self, int64_t index, const char *string)
Definition: libsheepyCSmallArray.c:13642
prependSmallBytesSmallArrayG
smallArrayt * prependSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:12783
escapeSmallArray
internal char * escapeSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1571
sliceSmallArrayG
smallArrayt * sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:13487
setAtSmallDoubleSmallArray
internal smallArrayt * setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:7958
icHasSmallArrayG
bool icHasSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:14155
getAtNDupUint32SmallArray
internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7397
prependNFreeSmallBoolSmallArray
internal smallArrayt * prependNFreeSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:3100
getAtDoublePSmallArrayG
double * getAtDoublePSmallArrayG(smallArrayt *self, double *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13004
finishManyG
#define finishManyG
Definition: libsheepyObject.h:385
smallDict::type
const char * type
Definition: libsheepyCSmallDict.h:1069
getAtInt32SmallArrayG
int32_t getAtInt32SmallArrayG(smallArrayt *self, int32_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13019
getAtBoolPSmallArrayG
bool * getAtBoolPSmallArrayG(smallArrayt *self, bool *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:12994
range
#define range(index, maxCount)
range loop ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a decl...
Definition: libsheepy.h:2772
setAtArraycSmallArray
internal smallArrayt * setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:7832
binarySearchDictSmallArrayG
ssize_t binarySearchDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:14095
indexOfSmallContainerSmallArrayG
ssize_t indexOfSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:14055
getAtNDupSmallContainerSmallArrayG
smallContainert * getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13195
pErrorNULL
pErrorNULL(iPrependS(&ks, "[1]"))
popSmallDoubleSmallArrayG
smallDoublet * popSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *retType UNUSED)
Definition: libsheepyCSmallArray.c:12680
getAtArraySmallArrayG
smallArrayt * getAtArraySmallArrayG(smallArrayt *self, smallArrayt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13059
fromCArraySmallArrayG
smallArrayt * fromCArraySmallArrayG(smallArrayt *self, const char **array, size_t size)
Definition: libsheepyCSmallArray.c:12430
pushSmallBoolSmallArray
internal smallArrayt * pushSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:1942
getAtSmallDoubleSmallArray
internal smallDoublet * getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7154
cropElemSSmallArrayG
char * cropElemSSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13537
dequeueNumSmallArray
internal double dequeueNumSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3668
isEBytesSmallArray
internal bool isEBytesSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12334
icBinarySearchCharSmallArrayG
ssize_t icBinarySearchCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14255
isOSmallBytes
#define isOSmallBytes(obj)
test if obj type is smallBytes
Definition: libsheepyObject.h:239
injectNFreeSmallJsonSmallArrayG
smallArrayt * injectNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *string)
Definition: libsheepyCSmallArray.c:13770
typesSmallArray
internal smallBytest * typesSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12263
injectNFreeSmallBytesSmallArrayG
smallArrayt * injectNFreeSmallBytesSmallArrayG(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:13755
injectNFreeSmallJsonSmallArray
internal smallArrayt * injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject)
Definition: libsheepyCSmallArray.c:5997
allocSContainer
sContainert * allocSContainer(void *data)
allocate a small container The container holds a pointer to a user buffer
Definition: libsheepySmall.c:239
injectSmallDoubleSmallArray
internal smallArrayt * injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject)
Definition: libsheepyCSmallArray.c:5749
pushCArraycSmallArrayG
smallArrayt * pushCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:12495
getAtNDupSmallBoolSmallArrayG
smallBoolt * getAtNDupSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13160
areAllEArraySmallArray
internal bool areAllEArraySmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12401
setAtDictSmallArrayG
smallArrayt * setAtDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13235
dequeueIntSmallArrayG
int64_t dequeueIntSmallArrayG(smallArrayt *self, int64_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12901
dequeueSmallBoolSmallArray
internal smallBoolt * dequeueSmallBoolSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3393
prependSmallJsonSmallArray
internal smallArrayt * prependSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:2980
appendTextSmallArrayG
bool appendTextSmallArrayG(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:14480
zipSmallJsonCCharSmallArray
internal smallArrayt * zipSmallJsonCCharSmallArray(smallArrayt *self, smallJsont *array1, const char **array2)
Definition: libsheepyCSmallArray.c:11624
insertNSmashSmallArrayG
smallArrayt * insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert)
Definition: libsheepyCSmallArray.c:13607
logBtrace
#define logBtrace
Definition: libsheepy.h:3249
injectNFreeSSmallArray
internal smallArrayt * injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject)
Definition: libsheepyCSmallArray.c:5925
isBlankSmallArrayG
bool isBlankSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14310
cropElemInt32SmallArrayG
int32_t cropElemInt32SmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13522
injectCArraycSmallArray
internal smallArrayt * injectCArraycSmallArray(smallArrayt *self, int64_t index, const char **toInject)
Definition: libsheepyCSmallArray.c:5633
fromArraySmallArray
internal smallArrayt * fromArraySmallArray(smallArrayt *self, char **array, size_t size)
Definition: libsheepyCSmallArray.c:1691
allocSUndefined
sUndefinedt * allocSUndefined(void)
allocate a small undefined object
Definition: libsheepySmall.c:345
prependCharSmallArray
internal smallArrayt * prependCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:2824
smallt::type
char type
Definition: libsheepySmall.h:68
injectNFreeArraySmallArrayG
smallArrayt * injectNFreeArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13740
joinSmallStringSSmallArray
internal char * joinSmallStringSSmallArray(smallArrayt *self, smallStringt *delim)
Definition: libsheepyCSmallArray.c:11459
setPAtDictSmallArray
internal smallArrayt * setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:8234
setAtArraySmallArray
internal smallArrayt * setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:7803
setAtSmallStringSmallArray
internal smallArrayt * setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:8043
areAllEIntSmallArray
internal bool areAllEIntSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12386
setTopNFreeO
#define setTopNFreeO(self, value)
Definition: libsheepyObject.h:583
binarySearchSmallArrayG
ssize_t binarySearchSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:14060
binarySearchSmallStringSmallArrayG
ssize_t binarySearchSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:14140
dequeueSmallStringSmallArray
internal smallStringt * dequeueSmallStringSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3580
sBytest::count
uint32_t count
Definition: libsheepySmall.h:183
writeStreamSmallArrayG
bool writeStreamSmallArrayG(smallArrayt *self, FILE *fp)
Definition: libsheepyCSmallArray.c:14475
pushSmallBytesSmallArray
internal smallArrayt * pushSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:1959
dequeueSmallContainerSmallArrayG
smallContainert * dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert *retType UNUSED)
Definition: libsheepyCSmallArray.c:12971
icHasArraySmallArray
internal bool icHasArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:10061
appendNSmashSmallArrayG
smallArrayt * appendNSmashSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13429
dequeueUintSmallArray
internal uint64_t dequeueUintSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3285
iterNextSmallArray
internal baset * iterNextSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11268
insertNSmashSmallJsonSmallArray
internal smallArrayt * insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert)
Definition: libsheepyCSmallArray.c:4999
pushArraySmallArrayG
smallArrayt * pushArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:12485
prependSmallBytesSmallArray
internal smallArrayt * prependSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:2929
injectNFreeSmallBoolSmallArrayG
smallArrayt * injectNFreeSmallBoolSmallArrayG(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:13750
forEachSmallArrayF
internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElementSmallArrayFt funcElem)
Definition: libsheepyCSmallArray.c:11053
indexOfUndefinedSmallArray
internal ssize_t indexOfUndefinedSmallArray(smallArrayt *self, undefinedt *u)
Definition: libsheepyCSmallArray.c:8790
dequeueBoolSmallArrayG
bool dequeueBoolSmallArrayG(smallArrayt *self, bool retType UNUSED)
Definition: libsheepyCSmallArray.c:12891
popDoubleSmallArrayG
double popDoubleSmallArrayG(smallArrayt *self, double retType UNUSED)
Definition: libsheepyCSmallArray.c:12630
pushSmallBytesSmallArrayG
smallArrayt * pushSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:12517
setAtIntSmallArrayG
smallArrayt * setAtIntSmallArrayG(smallArrayt *self, int64_t index, int64_t value)
Definition: libsheepyCSmallArray.c:13220
cropElemSmallJsonSmallArray
internal smallJsont * cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4664
pushNFreeSmallContainerSmallArrayG
smallArrayt * pushNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:12608
icSortSmallArrayG
smallArrayt * icSortSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:13815
removeSmallArray
internal smallArrayt * removeSmallArray(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:6085
readTextSmallArray
internal smallArrayt * readTextSmallArray(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:11999
forEachElementSmallArrayFt
bool(* forEachElementSmallArrayFt)(void *closure, baset *element)
user defined function called in the forEach loop this fucntion is a parameter to the forEach function...
Definition: libsheepyCSmallArray.h:1144
cropElemUintSmallArray
internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4316
prependIntSmallArrayG
smallArrayt * prependIntSmallArrayG(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:12731
dequeueSmallIntSmallArrayG
smallIntt * dequeueSmallIntSmallArrayG(smallArrayt *self, smallIntt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12951
pushNFreeArraySmallArray
internal smallArrayt * pushNFreeArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:2111
isEBoolSmallArray
internal bool isEBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12294
setAtNFreeSmallDoubleSmallArray
internal smallArrayt * setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value)
Definition: libsheepyCSmallArray.c:8188
injectSmallArrayG
smallArrayt * injectSmallArrayG(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:13617
icIndexOfArraySmallArray
internal ssize_t icIndexOfArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:10213
writeTextSmallArrayG
bool writeTextSmallArrayG(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:14460
prependUndefinedSmallArrayG
smallArrayt * prependUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED)
Definition: libsheepyCSmallArray.c:12716
cropElemSmallStringSmallArray
internal smallStringt * cropElemSmallStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4707
setAtUndefinedSmallArray
internal smallArrayt * setAtUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7666
sBoolt::type
char type
Definition: libsheepySmall.h:75
pushIntSmallArrayG
smallArrayt * pushIntSmallArrayG(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:12465
pushUndefinedSmallArrayG
smallArrayt * pushUndefinedSmallArrayG(smallArrayt *self, void *value UNUSED)
Definition: libsheepyCSmallArray.c:12450
smallStringFunctionst::toString
toStringSmallStringFt toString
Definition: libsheepyCSmallString.h:1253
setFromSmallArrayG
smallArrayt * setFromSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:12435
setAtNFreeUndefinedSmallArray
internal smallArrayt * setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u)
Definition: libsheepyCSmallArray.c:8125
hasSmallContainerSmallArrayG
bool hasSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:13965
setAtUndefinedSmallArrayG
smallArrayt * setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED)
Definition: libsheepyCSmallArray.c:13205
prependIntSmallArray
internal smallArrayt * prependIntSmallArray(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:2801
setAtCArraycSmallArrayG
smallArrayt * setAtCArraycSmallArrayG(smallArrayt *self, int64_t index, const char **array)
Definition: libsheepyCSmallArray.c:13250
setPAtNFreeDictSmallArrayG
smallArrayt * setPAtNFreeDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13389
hasSmallStringSmallArrayG
bool hasSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:13960
binarySearchSmallDoubleSmallArrayG
ssize_t binarySearchSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:14125
prependCArraycSmallArrayG
smallArrayt * prependCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:12761
registerMethodsSmallArray
void registerMethodsSmallArray(smallArrayFunctionst *f)
Definition: libsheepyCSmallArray.c:950
icIndexOfDictSmallArrayG
ssize_t icIndexOfDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:14215
hasDictSmallArrayG
bool hasDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13915
allocCArraySmallArray
smallArrayt * allocCArraySmallArray(const char **array)
Definition: libsheepyCSmallArray.c:1455
setAtSSmallArray
internal smallArrayt * setAtSSmallArray(smallArrayt *self, int64_t index, const char *string)
Definition: libsheepyCSmallArray.c:7746
prependNFreeArraycSmallArrayG
smallArrayt * prependNFreeArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:12839
fp
END_TEST FILE * fp
Definition: libsheepyObjectTest.c:2195
iterElementSmallArray
internal baset * iterElementSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11305
setAtSmallContainerSmallArray
internal smallArrayt * setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:8070
getAtUint32SmallArrayG
uint32_t getAtUint32SmallArrayG(smallArrayt *self, uint32_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13039
pushNFreeArraycSmallArray
internal smallArrayt * pushNFreeArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:2120
prependBoolSmallArray
internal smallArrayt * prependBoolSmallArray(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:2781
shCmpt
int(* shCmpt)(const void *a, const void *b)
Definition: libsheepy.h:3085
setAtNFreeSmallBoolSmallArrayG
smallArrayt * setAtNFreeSmallBoolSmallArrayG(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:13333
cast
#define cast(type, casted, toCast)
define variable and cast pointer
Definition: libsheepy.h:617
prependDictSmallArrayG
smallArrayt * prependDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:12746
binarySearchBoolSmallArrayG
ssize_t binarySearchBoolSmallArrayG(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:14070
pushNFreeArraycSmallArrayG
smallArrayt * pushNFreeArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:12573
injectCArraycSmallArrayG
smallArrayt * injectCArraycSmallArrayG(smallArrayt *self, int64_t index, const char **array)
Definition: libsheepyCSmallArray.c:13667
prependNFreeArraySmallArray
internal smallArrayt * prependNFreeArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3082
indexOfBoolSmallArray
internal ssize_t indexOfBoolSmallArray(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:8813
joinCharSSmallArrayG
char * joinCharSSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14340
indexOfSmallIntSmallArrayG
ssize_t indexOfSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:14040
icIndexOfArraycSmallArrayG
ssize_t icIndexOfArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:14225
appendNSmashSmallArray
internal smallArrayt * appendNSmashSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3815
pushNFreeSmallIntSmallArray
internal smallArrayt * pushNFreeSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:2156
setAtSmallJsonSmallArrayG
smallArrayt * setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value)
Definition: libsheepyCSmallArray.c:13287
setAtNFreeSmallArrayG
smallArrayt * setAtNFreeSmallArrayG(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:13303
getNumSmallArrayG
double getNumSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13409
prependArraySmallArrayG
smallArrayt * prependArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:12751
icBinarySearchDictSmallArrayG
ssize_t icBinarySearchDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:14260
icEqualSmallArrayArray
bool icEqualSmallArrayArray(smallArrayt *self, char **p2)
Definition: libsheepyCSmallArray.c:6761
pushNFreeSmallJsonSmallArray
internal smallArrayt * pushNFreeSmallJsonSmallArray(smallArrayt *self, smallJsont *value)
Definition: libsheepyCSmallArray.c:2165
setPAtSmallStringSmallArray
internal smallArrayt * setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:8322
indexOfArraycSmallArrayG
ssize_t indexOfArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:14015
pushSmallContainerSmallArray
internal smallArrayt * pushSmallContainerSmallArray(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:2048
injectSmallContainerSmallArrayG
smallArrayt * injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:13714
typeSmallStringSmallArray
internal smallStringt * typeSmallStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12211
setAtSmallContainerSmallArrayG
smallArrayt * setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:13297
injectNFreeSmallDoubleSmallArray
internal smallArrayt * injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject)
Definition: libsheepyCSmallArray.c:5979
c
char c
Definition: libsheepyObjectTest.c:246
cropElemSSmallArray
internal char * cropElemSSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4400
setAtSSmallArrayG
smallArrayt * setAtSSmallArrayG(smallArrayt *self, int64_t index, const char *string)
Definition: libsheepyCSmallArray.c:13225
hasCharSmallArrayG
bool hasCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:13910
toStringO
#define toStringO(obj)
convert data in obj to string
Definition: libsheepyObject.h:346
icEqualSmallArrayCArrayG
bool icEqualSmallArrayCArrayG(smallArrayt *self, const char **p2)
Definition: libsheepyCSmallArray.c:13860
icBinarySearchSmallJsonSmallArray
internal ssize_t icBinarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:10662
getAtSmallStringSmallArray
internal smallStringt * getAtSmallStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7228
popSmallContainerSmallArrayG
smallContainert * popSmallContainerSmallArrayG(smallArrayt *self, smallContainert *retType UNUSED)
Definition: libsheepyCSmallArray.c:12705
icIndexOfSmallArrayG
ssize_t icIndexOfSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:14200
prependSmallStringSmallArray
internal smallArrayt * prependSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:3001
sortFCmp
internal int sortFCmp(const void *a, const void *b, void *func)
Definition: libsheepyCSmallArray.c:6279
pushNFreeManySmallArray
internal smallArrayt * pushNFreeManySmallArray(smallArrayt *self,...)
Definition: libsheepyCSmallArray.c:2230
icSortSmallArray
internal smallArrayt * icSortSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:6396
zipSmallArrayG
smallArrayt * zipSmallArrayG(smallArrayt *self, smallArrayt *array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:14355
icBinarySearchDictSmallArray
internal ssize_t icBinarySearchDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:10466
prependNFreeSSmallArray
internal smallArrayt * prependNFreeSSmallArray(smallArrayt *self, char *string)
Definition: libsheepyCSmallArray.c:3064
setPAtArraySmallArrayG
smallArrayt * setPAtArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13374
resetSmallArray
internal void resetSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1643
insertNSmashSmallArray
internal smallArrayt * insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert)
Definition: libsheepyCSmallArray.c:4989
initiateAllocateSmallArray
void initiateAllocateSmallArray(smallArrayt **self)
Definition: libsheepyCSmallArray.c:1421
binarySearchSmallJsonSmallArray
internal ssize_t binarySearchSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:9783
setAtNFreeArraycSmallArrayG
smallArrayt * setAtNFreeArraycSmallArrayG(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:13328
injectArraycSmallArrayG
smallArrayt * injectArraycSmallArrayG(smallArrayt *self, int64_t index, char **array)
Definition: libsheepyCSmallArray.c:13662
fromArrayNFreeSmallArray
internal smallArrayt * fromArrayNFreeSmallArray(smallArrayt *self, char **array, size_t size)
Definition: libsheepyCSmallArray.c:1767
popSmallBytesSmallArray
internal smallBytest * popSmallBytesSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2511
popSmallStringSmallArrayG
smallStringt * popSmallStringSmallArrayG(smallArrayt *self, smallStringt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12695
icHasSmallStringSmallArray
internal bool icHasSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:10113
prependNFreeSmallContainerSmallArrayG
smallArrayt * prependNFreeSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:12874
zipArrayCharSmallArrayG
smallArrayt * zipArrayCharSmallArrayG(smallArrayt *self, char **array1, char **array2)
Definition: libsheepyCSmallArray.c:14415
readTextSmallJsonSmallArray
internal smallArrayt * readTextSmallJsonSmallArray(smallArrayt *self, smallJsont *filePath)
Definition: libsheepyCSmallArray.c:12033
appendTextSmallStringSmallArrayG
bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:14485
allocSDict
sDictt * allocSDict(void)
allocate a small dict
Definition: libsheepySmall.c:256
icIndexOfCharSmallArrayG
ssize_t icIndexOfCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14210
smallContainer::data
sContainert * data
pointer to data in smallContainer
Definition: libsheepyCSmallContainer.h:196
zipCharSmallArrayG
smallArrayt * zipCharSmallArrayG(smallArrayt *self, smallArrayt *array1, char **array2)
Definition: libsheepyCSmallArray.c:14405
getAtUint32PSmallArrayG
uint32_t * getAtUint32PSmallArrayG(smallArrayt *self, uint32_t *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13044
delSmallArray
internal smallArrayt * delSmallArray(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:6024
setAtNFreeSmallBytesSmallArray
internal smallArrayt * setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:8179
getAtNDupSmallJsonSmallArray
internal smallJsont * getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7553
areAllEStringSmallArray
internal bool areAllEStringSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12391
isEFaststringSmallArray
internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12324
icIndexOfCArraycSmallArray
internal ssize_t icIndexOfCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:10275
zipSmallJsonSmallJsonSmallArray
internal smallArrayt * zipSmallJsonSmallJsonSmallArray(smallArrayt *self, smallJsont *array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:11561
injectSmallIntSmallArrayG
smallArrayt * injectSmallIntSmallArrayG(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:13699
appendSmallArray
internal smallArrayt * appendSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3749
binarySearchCArraycSmallArrayG
ssize_t binarySearchCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:14110
injectSmallIntSmallArray
internal smallArrayt * injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject)
Definition: libsheepyCSmallArray.c:5766
indexOfArraySmallArray
internal ssize_t indexOfArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:8930
setAtNFreeSmallContainerSmallArrayG
smallArrayt * setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:13363
getAtSmallIntSmallArrayG
smallIntt * getAtSmallIntSmallArrayG(smallArrayt *self, smallIntt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13079
joinSmallStringSmallArrayG
smallStringt * joinSmallStringSmallArrayG(smallArrayt *self, smallStringt *delim)
Definition: libsheepyCSmallArray.c:14330
popInt32SmallArray
internal int32_t popInt32SmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2373
zipArraySmallJsonSmallArray
internal smallArrayt * zipArraySmallJsonSmallArray(smallArrayt *self, char **array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:11722
iterStartFromSmallArray
internal baset * iterStartFromSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:11171
shiftNSmashSmallJsonSmallArrayG
smallArrayt * shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:13475
icBinarySearchCharSmallArray
internal ssize_t icBinarySearchCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:10460
setAtIntSmallArray
internal smallArrayt * setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value)
Definition: libsheepyCSmallArray.c:7726
o
smallDictt * o
Definition: libsheepyObjectTest.c:31
prependNFreeDictSmallArray
internal smallArrayt * prependNFreeDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:3073
prependDoubleSmallArrayG
smallArrayt * prependDoubleSmallArrayG(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:12726
icIndexOfSmallArray
internal ssize_t icIndexOfSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:10126
icEqualSmallArrayBase
bool icEqualSmallArrayBase(smallArrayt *self, baset *p2)
Definition: libsheepyCSmallArray.c:6821
pushDoubleSmallArrayG
smallArrayt * pushDoubleSmallArrayG(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:12460
setAtSmallStringSmallArrayG
smallArrayt * setAtSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13292
smallContainer::f
smallContainerFunctionst * f
Definition: libsheepyCSmallContainer.h:193
fclose
fclose(fp)
dequeueDictSmallArray
internal smallDictt * dequeueDictSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3321
readStreamSmallArrayG
smallArrayt * readStreamSmallArrayG(smallArrayt *self, FILE *fp)
Definition: libsheepyCSmallArray.c:14455
sArrayPrependTiny
void sArrayPrependTiny(sArrayt **array, smallt *data)
prepend data in array
Definition: libsheepySmall.c:1617
icIndexOfSSmallArray
internal ssize_t icIndexOfSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:10153
pushManySmallArray
internal smallArrayt * pushManySmallArray(smallArrayt *self,...)
Definition: libsheepyCSmallArray.c:2192
toStringListSGF
char * toStringListSGF(char **object)
Definition: libsheepyObject.c:1279
setAtNFreeSmallIntSmallArrayG
smallArrayt * setAtNFreeSmallIntSmallArrayG(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:13348
binarySearchCharSmallArray
internal ssize_t binarySearchCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:9424
dequeueSmallBoolSmallArrayG
smallBoolt * dequeueSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12936
pushArraySmallArray
internal smallArrayt * pushArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:1877
icIndexOfSmallJsonSmallArrayG
ssize_t icIndexOfSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:14235
toBaset
baset * toBaset(smallt *obj)
convert smallt object to baset
Definition: libsheepyObject.c:5499
dequeueDictSmallArrayG
smallDictt * dequeueDictSmallArrayG(smallArrayt *self, smallDictt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12926
binarySearchUndefinedSmallArray
internal ssize_t binarySearchUndefinedSmallArray(smallArrayt *self UNUSED, undefinedt *u UNUSED)
Definition: libsheepyCSmallArray.c:9253
getAtNDupDoubleSmallArray
internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7349
cropElemSmallBytesSmallArray
internal smallBytest * cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4553
getAtNDupUndefinedSmallArray
internal undefinedt * getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7315
pushNFreeSmallIntSmallArrayG
smallArrayt * pushNFreeSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:12593
sIntt::value
int64_t value
Definition: libsheepySmall.h:130
disposeO
#define disposeO(self)
Definition: libsheepyObject.h:7497
trimSmallArrayG
smallArrayt * trimSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:13875
dequeueSmallIntSmallArray
internal smallIntt * dequeueSmallIntSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3501
cropElemDoubleSmallArrayG
double cropElemDoubleSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13512
indexOfDictSmallArrayG
ssize_t indexOfDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:14005
prependNFreeSmallStringSmallArrayG
smallArrayt * prependNFreeSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:12869
binarySearchSmallIntSmallArray
internal ssize_t binarySearchSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:9744
isOSmallDouble
#define isOSmallDouble(obj)
test if obj type is smallDouble
Definition: libsheepyObject.h:257
sArraySetTiny
void sArraySetTiny(sArrayt *array, uint32_t index, smallt *value)
set value at index
Definition: libsheepySmall.c:1761
pushSmallIntSmallArrayG
smallArrayt * pushSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:12527
getAtInt32PSmallArray
internal int32_t * getAtInt32PSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6994
sBytesGet
void * sBytesGet(sBytest *bytes)
get buffer in small bytes
Definition: libsheepySmall.c:1852
appendSmallJsonSmallArray
internal smallArrayt * appendSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:3779
cropElemSmallStringSmallArrayG
smallStringt * cropElemSmallStringSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13577
pushNFreeSmallDoubleSmallArrayG
smallArrayt * pushNFreeSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:12588
prependNFreeSmallBytesSmallArrayG
smallArrayt * prependNFreeSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:12849
setAtNFreeUndefinedSmallArrayG
smallArrayt * setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value)
Definition: libsheepyCSmallArray.c:13308
hasSmallArrayG
bool hasSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:13880
dequeueSmallArrayG
baset * dequeueSmallArrayG(smallArrayt *self, baset *retType UNUSED)
Definition: libsheepyCSmallArray.c:12881
binarySearchIntSmallArrayG
ssize_t binarySearchIntSmallArrayG(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:14080
areAllEBytesSmallArray
internal bool areAllEBytesSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12406
popIntSmallArray
internal int64_t popIntSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2361
icHasArraySmallArrayG
bool icHasArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:14175
injectNFreeUndefinedSmallArray
internal smallArrayt * injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *u)
Definition: libsheepyCSmallArray.c:5916
indexOfSmallDoubleSmallArray
internal ssize_t indexOfSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:9072
zipCArraySmallArrayG
smallArrayt * zipCArraySmallArrayG(smallArrayt *self, const char **array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:14390
setPAtSmallStringSmallArrayG
smallArrayt * setPAtSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13384
pushNFreeSmallJsonSmallArrayG
smallArrayt * pushNFreeSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value)
Definition: libsheepyCSmallArray.c:12598
equalSmallArray
internal bool equalSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:6447
removeElemSmallArray
internal smallArrayt * removeElemSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6129
prependDoubleSmallArray
internal smallArrayt * prependDoubleSmallArray(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:2791
getAtDoublePSmallArray
internal double * getAtDoublePSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6946
icUniqSmallArrayG
smallArrayt * icUniqSmallArrayG(smallArrayt *self, int dum UNUSED)
Definition: libsheepyCSmallArray.c:14290
setAtNFreeArraySmallArrayG
smallArrayt * setAtNFreeArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13323
injectSmallJsonSmallArray
internal smallArrayt * injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject)
Definition: libsheepyCSmallArray.c:5783
allocSDouble
sDoublet * allocSDouble(double value)
allocate a small double
Definition: libsheepySmall.c:274
popInt32SmallArrayG
int32_t popInt32SmallArrayG(smallArrayt *self, int32_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12640
isOSmallDict
#define isOSmallDict(obj)
test if obj type is smallDictt
Definition: libsheepyObject.h:251
zipArrayCCharSmallArrayG
smallArrayt * zipArrayCCharSmallArrayG(smallArrayt *self, char **array1, const char **array2)
Definition: libsheepyCSmallArray.c:14420
dequeueArraySmallArrayG
smallArrayt * dequeueArraySmallArrayG(smallArrayt *self, smallArrayt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12931
indexOfUndefinedSmallArrayG
ssize_t indexOfUndefinedSmallArrayG(smallArrayt *self, undefinedt *value)
Definition: libsheepyCSmallArray.c:13975
shiftSmallArrayG
smallArrayt * shiftSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13454
getAtSmallContainerSmallArrayG
smallContainert * getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13099
BLD
#define BLD
bold for color function
Definition: libsheepy.h:765
injectSmallJsonSmallArrayG
smallArrayt * injectSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *string)
Definition: libsheepyCSmallArray.c:13704
prependNFreeUndefinedSmallArrayG
smallArrayt * prependNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value)
Definition: libsheepyCSmallArray.c:12819
setAtCharSmallArrayG
smallArrayt * setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c)
Definition: libsheepyCSmallArray.c:13230
popSmallArray
internal baset * popSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2269
getAtUndefinedSmallArrayG
undefinedt * getAtUndefinedSmallArrayG(smallArrayt *self, undefinedt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:12984
hasArraySmallArray
internal bool hasArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:8601
enumerateCS
#define enumerateCS(list, element, index)
enumerateCS const list to acess the element in the loop, use element ;size_t needed to avoid: error: ...
Definition: libsheepy.h:3047
indexOfDoubleSmallArray
internal ssize_t indexOfDoubleSmallArray(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:8832
dupS
char * dupS(const char *string)
duplicate string
Definition: libsheepy.c:6548
prependCharSmallArrayG
smallArrayt * prependCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:12741
getAtSmallBoolSmallArray
internal smallBoolt * getAtSmallBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7110
joinSmallJsonSmallArrayG
smallStringt * joinSmallJsonSmallArrayG(smallArrayt *self, smallJsont *delim)
Definition: libsheepyCSmallArray.c:14325
getAtNDupArraySmallArray
internal smallArrayt * getAtNDupArraySmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7443
dequeueSmallDoubleSmallArrayG
smallDoublet * dequeueSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *retType UNUSED)
Definition: libsheepyCSmallArray.c:12946
setsoO
#define setsoO(self, so)
Definition: libsheepyObject.h:7509
zipCArrayCharSmallArray
internal smallArrayt * zipCArrayCharSmallArray(smallArrayt *self, const char **array1, char **array2)
Definition: libsheepyCSmallArray.c:11879
getAtNDupArraySmallArrayG
smallArrayt * getAtNDupArraySmallArrayG(smallArrayt *self, smallArrayt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13155
zipCArrayCCharSmallArrayG
smallArrayt * zipCArrayCCharSmallArrayG(smallArrayt *self, const char **array1, const char **array2)
Definition: libsheepyCSmallArray.c:14430
joinSSmallArray
internal char * joinSSmallArray(smallArrayt *self, const char *delim)
Definition: libsheepyCSmallArray.c:11391
indexOfCharSmallArrayG
ssize_t indexOfCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14000
smallArrayFunctionst::toString
toStringSmallArrayFt toString
Definition: libsheepyCSmallArray.h:1881
getAtIntSmallArray
internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6958
createSmallArray
END_TEST createSmallArray(obj)
pushSmallJsonSmallArray
internal smallArrayt * pushSmallJsonSmallArray(smallArrayt *self, smallJsont *value)
Definition: libsheepyCSmallArray.c:2010
popSSmallArrayG
char * popSSmallArrayG(smallArrayt *self, char *retType UNUSED)
Definition: libsheepyCSmallArray.c:12655
setsoSmallArray
internal void setsoSmallArray(smallArrayt *self, sArrayt *so)
Definition: libsheepyCSmallArray.c:1660
listLengthCS
size_t listLengthCS(const char **list)
const list Length String return number of elements until the first NULL element
Definition: libsheepy.c:50843
injectBoolSmallArrayG
smallArrayt * injectBoolSmallArrayG(smallArrayt *self, int64_t index, bool value)
Definition: libsheepyCSmallArray.c:13627
dequeueDoubleSmallArray
internal double dequeueDoubleSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3249
appendNSmashArraySmallArray
internal smallArrayt * appendNSmashArraySmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:3875
pushArraycSmallArray
internal smallArrayt * pushArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:1896
strEq
#define strEq
Definition: libsheepy.h:2018
pushSmallJsonSmallArrayG
smallArrayt * pushSmallJsonSmallArrayG(smallArrayt *self, smallJsont *value)
Definition: libsheepyCSmallArray.c:12532
icHasCArraycSmallArrayG
bool icHasCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:14185
json
initiateAllocateSmallJson & json
Definition: libsheepyObjectTest.c:911
areAllEFaststringSmallArray
internal bool areAllEFaststringSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12396
pushNFreeSmallBytesSmallArray
internal smallArrayt * pushNFreeSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:2138
indexOfSmallBytesSmallArrayG
ssize_t indexOfSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:14030
setPAtNFreeArraySmallArray
internal smallArrayt * setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:8383
writeTextSmallJsonSmallArrayG
bool writeTextSmallJsonSmallArrayG(smallArrayt *self, smallJsont *filePath)
Definition: libsheepyCSmallArray.c:14465
injectSSmallArray
internal smallArrayt * injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject)
Definition: libsheepyCSmallArray.c:5331
setAtSmallIntSmallArray
internal smallArrayt * setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:7985
cropElemUint32SmallArrayG
uint32_t cropElemUint32SmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13532
a
smallArrayt * a
Definition: libsheepyObjectTest.c:2316
dequeueIntSmallArray
internal int64_t dequeueIntSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3261
value
in value value
Definition: libsheepyObjectTest.c:1363
zipArraySmallJsonSmallArrayG
smallArrayt * zipArraySmallJsonSmallArrayG(smallArrayt *self, char **array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:14395
isOSmallBool
#define isOSmallBool(obj)
test if obj type is smallBool
Definition: libsheepyObject.h:233
indexOfSmallJsonSmallArray
internal ssize_t indexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:9122
prependSSmallArrayG
smallArrayt * prependSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:12736
popVoidSmallArray
internal void * popVoidSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2669
iAppendS
char * iAppendS(char **string1, const char *string2)
append strings
Definition: libsheepy.c:7285
injectNFreeSmallContainerSmallArrayG
smallArrayt * injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:13780
popBoolSmallArrayG
bool popBoolSmallArrayG(smallArrayt *self, bool retType UNUSED)
Definition: libsheepyCSmallArray.c:12625
hasSmallDoubleSmallArray
internal bool hasSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:8678
prependSmallContainerSmallArray
internal smallArrayt * prependSmallContainerSmallArray(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:3018
pushNFreeDictSmallArrayG
smallArrayt * pushNFreeDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:12563
setAtArraySmallArrayG
smallArrayt * setAtArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13240
finishSmallArray
internal void finishSmallArray(smallArrayt **self)
Definition: libsheepyCSmallArray.c:1622
injectNFreeSmallStringSmallArray
internal smallArrayt * injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject)
Definition: libsheepyCSmallArray.c:6006
hasUndefinedSmallArray
internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *u)
Definition: libsheepyCSmallArray.c:8521
equalSmallArraySmallJsonG
bool equalSmallArraySmallJsonG(smallArrayt *self, smallJsont *array)
Definition: libsheepyCSmallArray.c:13825
copySmallArrayG
smallArrayt * copySmallArrayG(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:13592
cropSmallArray
internal smallArrayt * cropSmallArray(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:4001
cropElemSmallBoolSmallArrayG
smallBoolt * cropElemSmallBoolSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13552
icIndexOfCArraycSmallArrayG
ssize_t icIndexOfCArraycSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:14230
injectIntSmallArrayG
smallArrayt * injectIntSmallArrayG(smallArrayt *self, int64_t index, int64_t value)
Definition: libsheepyCSmallArray.c:13637
setPAtNFreeDictSmallArray
internal smallArrayt * setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:8352
sDictt
dictionary
Definition: libsheepySmall.h:109
hasSSmallArrayG
bool hasSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:13905
getAtDoubleSmallArray
internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6934
dequeueVoidSmallArray
internal void * dequeueVoidSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3616
delElemSmallArray
internal smallArrayt * delElemSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6066
shiftNSmashSmallArray
internal smallArrayt * shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3909
trim
o f trim(o)
cropElemSmallIntSmallArrayG
smallIntt * cropElemSmallIntSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13567
cropElemArraySmallArray
internal smallArrayt * cropElemArraySmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4479
icEqualSmallArraySmallJsonG
bool icEqualSmallArraySmallJsonG(smallArrayt *self, smallJsont *array)
Definition: libsheepyCSmallArray.c:13850
popSmallIntSmallArrayG
smallIntt * popSmallIntSmallArrayG(smallArrayt *self, smallIntt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12685
icIndexOfSmallStringSmallArrayG
ssize_t icIndexOfSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:14240
sDoublet::value
double value
Definition: libsheepySmall.h:122
pushDictSmallArrayG
smallArrayt * pushDictSmallArrayG(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:12480
zipSmallJsonSmallArraySmallArrayG
smallArrayt * zipSmallJsonSmallArraySmallArrayG(smallArrayt *self, smallJsont *array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:14365
getAtUint32PSmallArray
internal uint32_t * getAtUint32PSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7042
pushSmallStringSmallArrayG
smallArrayt * pushSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:12537
setAtNFreeSmallBoolSmallArray
internal smallArrayt * setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:8170
prependCArraycSmallArray
internal smallArrayt * prependCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:2890
setAtBoolSmallArrayG
smallArrayt * setAtBoolSmallArrayG(smallArrayt *self, int64_t index, bool value)
Definition: libsheepyCSmallArray.c:13210
popUint32SmallArray
internal uint32_t popUint32SmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2397
getNumSmallArray
internal double getNumSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:8475
binarySearchSSmallArrayG
ssize_t binarySearchSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:14085
icHasCharSmallArrayG
bool icHasCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14165
prependNFreeArraycSmallArray
internal smallArrayt * prependNFreeArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:3091
sEscape
char * sEscape(smallt *obj)
stringify object
Definition: libsheepySmall.c:949
logSmallArray
internal void logSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11978
injectBoolSmallArray
internal smallArrayt * injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject)
Definition: libsheepyCSmallArray.c:5142
dequeueUndefinedSmallArrayG
undefinedt * dequeueUndefinedSmallArrayG(smallArrayt *self, undefinedt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12886
pushCharSmallArrayG
smallArrayt * pushCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:12475
equalSmallArrayCArrayG
bool equalSmallArrayCArrayG(smallArrayt *self, const char **p2)
Definition: libsheepyCSmallArray.c:13835
joinSmallJsonSmallArray
internal smallStringt * joinSmallJsonSmallArray(smallArrayt *self, smallJsont *delim)
Definition: libsheepyCSmallArray.c:11364
zipSmallJsonSmallJsonSmallArrayG
smallArrayt * zipSmallJsonSmallJsonSmallArrayG(smallArrayt *self, smallJsont *array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:14370
sStringt
small string
Definition: libsheepySmall.h:136
compactSmallArrayG
smallArrayt * compactSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14295
getAtNDupDoubleSmallArrayG
double getAtNDupDoubleSmallArrayG(smallArrayt *self, double retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13120
areAllEDoubleSmallArray
internal bool areAllEDoubleSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12381
readTextSmallArrayG
smallArrayt * readTextSmallArrayG(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:14440
popUintSmallArray
internal uint64_t popUintSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2385
getAtNDupUint32SmallArrayG
uint32_t getAtNDupUint32SmallArrayG(smallArrayt *self, uint32_t retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13140
binarySearchCharSmallArrayG
ssize_t binarySearchCharSmallArrayG(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:14090
allocUndefined
undefinedt * allocUndefined(void)
Definition: libsheepyCUndefined.c:107
removeSmallArrayG
smallArrayt * removeSmallArrayG(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:13795
setAtSmallIntSmallArrayG
smallArrayt * setAtSmallIntSmallArrayG(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:13282
zipSmallArray
internal smallArrayt * zipSmallArray(smallArrayt *self, smallArrayt *array1, smallArrayt *array2)
Definition: libsheepyCSmallArray.c:11467
binarySearchDictSmallArray
internal ssize_t binarySearchDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:9430
setAtSmallArrayG
smallArrayt * setAtSmallArrayG(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:13200
equalSmallArrayBase
internal bool equalSmallArrayBase(smallArrayt *self, baset *p2)
Definition: libsheepyCSmallArray.c:6623
getAtSSmallArray
internal char * getAtSSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7054
icHasSmallArray
internal bool icHasSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:10016
icHasDictSmallArray
internal bool icHasDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:10048
sBoolt
small bool
Definition: libsheepySmall.h:74
getAtUint32SmallArray
internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7030
cleanUpSmallArrayFinishG
void cleanUpSmallArrayFinishG(smallArrayt **val)
Definition: libsheepyCSmallArray.c:1478
prependNFreeSmallArrayG
smallArrayt * prependNFreeSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:12814
injectVoidSmallArrayG
smallArrayt * injectVoidSmallArrayG(smallArrayt *self, int64_t index, void *value)
Definition: libsheepyCSmallArray.c:13672
cropElemSmallBoolSmallArray
internal smallBoolt * cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4516
getAtVoidSmallArray
internal void * getAtVoidSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7250
popSmallJsonSmallArrayG
smallJsont * popSmallJsonSmallArrayG(smallArrayt *self, smallJsont *retType UNUSED)
Definition: libsheepyCSmallArray.c:12690
insertSmallArrayG
smallArrayt * insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert)
Definition: libsheepyCSmallArray.c:13597
prependNFreeSmallIntSmallArrayG
smallArrayt * prependNFreeSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:12859
dequeueVoidSmallArrayG
void * dequeueVoidSmallArrayG(smallArrayt *self, void *retType UNUSED)
Definition: libsheepyCSmallArray.c:12966
smallJson::f
smallJsonFunctionst * f
Definition: libsheepyCSmallJson.h:3487
areAllEBoolSmallArray
internal bool areAllEBoolSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12366
smallArrayFunctionst::terminate
terminateSmallArrayFt terminate
Definition: libsheepyCSmallArray.h:1880
getAtNDupIntSmallArray
internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7361
fromCArraySmallArray
internal smallArrayt * fromCArraySmallArray(smallArrayt *self, const char **array, size_t size)
Definition: libsheepyCSmallArray.c:1729
indexOfSmallArrayG
ssize_t indexOfSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:13970
toSmallt
smallt * toSmallt(baset *obj)
convert baset object to smallt
Definition: libsheepyObject.c:5426
getAtArraySmallArray
internal smallArrayt * getAtArraySmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7088
getAtIntPSmallArrayG
int64_t * getAtIntPSmallArrayG(smallArrayt *self, int64_t *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13014
indexOfSmallArray
internal ssize_t indexOfSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:8763
isETypeSmallArray
internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type)
Definition: libsheepyCSmallArray.c:12280
writeTextSmallStringSmallArrayG
bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:14470
pushNFreeSmallDoubleSmallArray
internal smallArrayt * pushNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:2147
appendTextSmallStringSmallArray
internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath)
Definition: libsheepyCSmallArray.c:12192
setAtNFreeSmallIntSmallArray
internal smallArrayt * setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:8197
QSORT
#define QSORT(Q_N, Q_LESS, Q_SWAP)
Definition: libsheepy.h:1516
uniqSmallArray
internal smallArrayt * uniqSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:9888
UNUSED
#define UNUSED
Definition: libsheepy.h:8195
allocSBool
sBoolt * allocSBool(bool value)
allocate a small bool
Definition: libsheepySmall.c:221
dequeueSmallContainerSmallArray
internal smallContainert * dequeueSmallContainerSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3628
allocArraySmallArray
smallArrayt * allocArraySmallArray(char **array)
Definition: libsheepyCSmallArray.c:1447
pushNFreeSSmallArray
internal smallArrayt * pushNFreeSSmallArray(smallArrayt *self, char *string)
Definition: libsheepyCSmallArray.c:2093
equalSmallArrayG
bool equalSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13820
zipSmallJsonCharSmallArrayG
smallArrayt * zipSmallJsonCharSmallArrayG(smallArrayt *self, smallJsont *array1, char **array2)
Definition: libsheepyCSmallArray.c:14375
icIndexOfArraySmallArrayG
ssize_t icIndexOfArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:14220
pushNFreeUndefinedSmallArray
internal smallArrayt * pushNFreeUndefinedSmallArray(smallArrayt *self, undefinedt *u)
Definition: libsheepyCSmallArray.c:2084
sArrayFreeTiny
void sArrayFreeTiny(sArrayt *array)
free array elements and array object
Definition: libsheepySmall.c:470
equalSmallArrayBaseG
bool equalSmallArrayBaseG(smallArrayt *self, baset *p2)
Definition: libsheepyCSmallArray.c:13840
injectSmallStringSmallArrayG
smallArrayt * injectSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13709
getAtNDupDictSmallArrayG
smallDictt * getAtNDupDictSmallArrayG(smallArrayt *self, smallDictt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13150
uniqSmallArrayG
smallArrayt * uniqSmallArrayG(smallArrayt *self, int dum UNUSED)
Definition: libsheepyCSmallArray.c:14150
injectNFreeSmallStringSmallArrayG
smallArrayt * injectNFreeSmallStringSmallArrayG(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:13775
getAtInt32SmallArray
internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6982
hasSmallContainerSmallArray
internal bool hasSmallContainerSmallArray(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:8746
icHasSmallStringSmallArrayG
bool icHasSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:14195
dequeueUint32SmallArray
internal uint32_t dequeueUint32SmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3297
forEachCharP
#define forEachCharP(list, element)
forEach - loop macro on list indexes to access the element in the loop, use *element ...
Definition: libsheepy.h:2979
binarySearchSmallArray
internal ssize_t binarySearchSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:9215
cropElemVoidSmallArrayG
void * cropElemVoidSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13582
delElemSmallArrayG
smallArrayt * delElemSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13790
setAtNFreeSSmallArrayG
smallArrayt * setAtNFreeSSmallArrayG(smallArrayt *self, int64_t index, char *string)
Definition: libsheepyCSmallArray.c:13313
icHasArraycSmallArray
internal bool icHasArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:10074
allocSmallString
smallStringt * allocSmallString(const char *string)
Definition: libsheepyCSmallString.c:827
prependNFreeSmallDoubleSmallArray
internal smallArrayt * prependNFreeSmallDoubleSmallArray(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:3118
setAtCArraycSmallArray
internal smallArrayt * setAtCArraycSmallArray(smallArrayt *self, int64_t index, const char **array)
Definition: libsheepyCSmallArray.c:7868
dequeueUndefinedSmallArray
internal undefinedt * dequeueUndefinedSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3200
popSmallArrayG
baset * popSmallArrayG(smallArrayt *self, baset *retType UNUSED)
Definition: libsheepyCSmallArray.c:12615
indexOfSmallBytesSmallArray
internal ssize_t indexOfSmallBytesSmallArray(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:9046
getTopO
#define getTopO(self)
Definition: libsheepyObject.h:601
popUintSmallArrayG
uint64_t popUintSmallArrayG(smallArrayt *self, uint64_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12645
icHasSmallJsonSmallArrayG
bool icHasSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:14190
popDictSmallArrayG
smallDictt * popDictSmallArrayG(smallArrayt *self, smallDictt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12660
smallBool::f
smallBoolFunctionst * f
Definition: libsheepyCSmallBool.h:226
cropElemBoolSmallArray
internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4147
getAtNDupSmallStringSmallArray
internal smallStringt * getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7584
getValO
#define getValO(self)
get value in smallBool, smallBytes, smallDouble, smallInt, smallString
Definition: libsheepyObject.h:474
setAtSmallBytesSmallArrayG
smallArrayt * setAtSmallBytesSmallArrayG(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:13272
iterStartFromStepSmallArray
internal baset * iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step)
Definition: libsheepyCSmallArray.c:11217
dequeueSmallJsonSmallArrayG
smallJsont * dequeueSmallJsonSmallArrayG(smallArrayt *self, smallJsont *retType UNUSED)
Definition: libsheepyCSmallArray.c:12956
getAtNDupSmallIntSmallArrayG
smallIntt * getAtNDupSmallIntSmallArrayG(smallArrayt *self, smallIntt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13175
dequeueSSmallArrayG
char * dequeueSSmallArrayG(smallArrayt *self, char *retType UNUSED)
Definition: libsheepyCSmallArray.c:12921
isEArraySmallArray
internal bool isEArraySmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12329
setPAtNFreeArraySmallArrayG
smallArrayt * setPAtNFreeArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13394
joinSmallJsonSSmallArray
internal char * joinSmallJsonSSmallArray(smallArrayt *self, smallJsont *delim)
Definition: libsheepyCSmallArray.c:11440
dequeueSmallBytesSmallArray
internal smallBytest * dequeueSmallBytesSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3429
rangeFrom
#define rangeFrom(index, from, maxCount)
range loop starting at value from ;size_t UNIQVAR needed to avoid: error: a label can only be part of...
Definition: libsheepy.h:2803
hasArraycSmallArray
internal bool hasArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:8618
equalSmallArraySmallJson
internal bool equalSmallArraySmallJson(smallArrayt *self, smallJsont *array)
Definition: libsheepyCSmallArray.c:6549
injectNFreeSmallIntSmallArrayG
smallArrayt * injectNFreeSmallIntSmallArrayG(smallArrayt *self, int64_t index, smallIntt *value)
Definition: libsheepyCSmallArray.c:13765
sortSCmp
internal int sortSCmp(const void *a, const void *b)
Definition: libsheepyCSmallArray.c:6148
pushSmallIntSmallArray
internal smallArrayt * pushSmallIntSmallArray(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:1993
cropElemVoidSmallArray
internal void * cropElemVoidSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4744
trimSmallArray
internal smallArrayt * trimSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:6846
r
bool r
Definition: libsheepyObjectTest.c:1259
setAtNFreeSmallBytesSmallArrayG
smallArrayt * setAtNFreeSmallBytesSmallArrayG(smallArrayt *self, int64_t index, smallBytest *value)
Definition: libsheepyCSmallArray.c:13338
setAtNFreeSmallStringSmallArray
internal smallArrayt * setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:8215
prependUndefinedSmallArray
internal smallArrayt * prependUndefinedSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2771
sjGet
#define sjGet(obj)
get a pointer to the string in the smallJson object
Definition: libsheepyObject.h:9817
injectArraycSmallArray
internal smallArrayt * injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject)
Definition: libsheepyCSmallArray.c:5551
logW
#define logW(...)
Definition: libsheepy.h:1061
getAtNDupSSmallArrayG
char * getAtNDupSSmallArrayG(smallArrayt *self, char *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13145
prependVoidSmallArrayG
smallArrayt * prependVoidSmallArrayG(smallArrayt *self, void *value)
Definition: libsheepyCSmallArray.c:12766
toStringSmallArray
internal char * toStringSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:1540
indexOfSSmallArray
internal ssize_t indexOfSSmallArray(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:8870
copySmallArray
internal smallArrayt * copySmallArray(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:4823
shEPrintfS
void shEPrintfS(const char *fmt,...)
sheepy Error printf String print with logE
Definition: libsheepy.c:6589
SWAPsa
#define SWAPsa(i, j)
Definition: libsheepyCSmallArrayInternal.h:30
getAtUintPSmallArrayG
uint64_t * getAtUintPSmallArrayG(smallArrayt *self, uint64_t *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13034
setAtNFreeSSmallArray
internal smallArrayt * setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string)
Definition: libsheepyCSmallArray.c:8134
indexOfBoolSmallArrayG
ssize_t indexOfBoolSmallArrayG(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:13980
LESSsa
#define LESSsa(i, j)
Definition: libsheepyCSmallArrayInternal.h:29
getAtNDupSmallBoolSmallArray
internal smallBoolt * getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7465
popSmallContainerSmallArray
internal smallContainert * popSmallContainerSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2681
base
base class
Definition: libsheepyObject.h:9597
icUniqSmallArray
internal smallArrayt * icUniqSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:10761
sArrayGetTiny
smallt * sArrayGetTiny(sArrayt *array, uint32_t index)
get object at index
Definition: libsheepySmall.c:1713
freeO
#define freeO(obj)
free buffers in obj
Definition: libsheepyObject.h:171
zipSmallJsonCCharSmallArrayG
smallArrayt * zipSmallJsonCCharSmallArrayG(smallArrayt *self, smallJsont *array1, const char **array2)
Definition: libsheepyCSmallArray.c:14380
prependNFreeArraySmallArrayG
smallArrayt * prependNFreeArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:12834
getAtSmallStringSmallArrayG
smallStringt * getAtSmallStringSmallArrayG(smallArrayt *self, smallStringt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13089
insertNSmashSmallJsonSmallArrayG
smallArrayt * insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert)
Definition: libsheepyCSmallArray.c:13612
setAtNFreeSmallContainerSmallArray
internal smallArrayt * setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container)
Definition: libsheepyCSmallArray.c:8224
sDoublet
small double
Definition: libsheepySmall.h:120
setPAtNFreeSmallStringSmallArray
internal smallArrayt * setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string)
Definition: libsheepyCSmallArray.c:8444
injectNFreeSmallIntSmallArray
internal smallArrayt * injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject)
Definition: libsheepyCSmallArray.c:5988
injectNFreeSSmallArrayG
smallArrayt * injectNFreeSSmallArrayG(smallArrayt *self, int64_t index, char *string)
Definition: libsheepyCSmallArray.c:13730
getAtBoolSmallArray
internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6910
getAtNDupInt32SmallArray
internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7373
hasBoolSmallArray
internal bool hasBoolSmallArray(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:8538
zipCArrayCCharSmallArray
internal smallArrayt * zipCArrayCCharSmallArray(smallArrayt *self, const char **array1, const char **array2)
Definition: libsheepyCSmallArray.c:11945
icBinarySearchSSmallArrayG
ssize_t icBinarySearchSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:14250
cropElemUndefinedSmallArray
internal undefinedt * cropElemUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4111
pushNFreeSmallArray
internal smallArrayt * pushNFreeSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:2066
pushNFreeSmallArrayG
smallArrayt * pushNFreeSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:12548
hasCArraycSmallArray
internal bool hasCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:8631
rangeFromStep
#define rangeFromStep(index, from, maxCount, step)
range step loop starting at value from ;size_t UNIQVAR needed to avoid: error: a label can only be pa...
Definition: libsheepy.h:2897
hasSmallStringSmallArray
internal bool hasSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:8729
enumerateSArray
#define enumerateSArray(array, element, index)
Definition: libsheepySmall.h:272
sFree
void sFree(smallt *obj)
free non null objects
Definition: libsheepySmall.c:371
appendCArraySmallArrayG
smallArrayt * appendCArraySmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:13449
sIntt::type
char type
Definition: libsheepySmall.h:129
setAtNFreeDictSmallArrayG
smallArrayt * setAtNFreeDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13318
cropElemArraySmallArrayG
smallArrayt * cropElemArraySmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13547
lenSmallArray
internal size_t lenSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:6837
sortSmallArrayG
smallArrayt * sortSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:13805
popUndefinedSmallArray
internal undefinedt * popUndefinedSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2306
cropElemSmallBytesSmallArrayG
smallBytest * cropElemSmallBytesSmallArrayG(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:13557
enumerateElementSmallArrayFt
bool(* enumerateElementSmallArrayFt)(void *closure, size_t index, baset *element)
user defined function called in the enumerate loop this fucntion is a parameter to the enumerate func...
Definition: libsheepyCSmallArray.h:1170
icBinarySearchCArraycSmallArray
internal ssize_t icBinarySearchCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:10615
dequeueDoubleSmallArrayG
double dequeueDoubleSmallArrayG(smallArrayt *self, double retType UNUSED)
Definition: libsheepyCSmallArray.c:12896
appendTextSmallArray
internal bool appendTextSmallArray(smallArrayt *self, const char *filePath)
Definition: libsheepyCSmallArray.c:12165
icBinarySearchArraycSmallArray
internal ssize_t icBinarySearchArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:10568
injectSmallArray
internal smallArrayt * injectSmallArray(smallArrayt *self, int64_t index, baset *toInject)
Definition: libsheepyCSmallArray.c:5010
isEmptySmallArray
internal bool isEmptySmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:10988
binarySearchSmallContainerSmallArrayG
ssize_t binarySearchSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:14145
appendNSmashSmallJsonSmallArrayG
smallArrayt * appendNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:13434
setAtNFreeArraySmallArray
internal smallArrayt * setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:8152
listLengthS
size_t listLengthS(char **list)
list Length String return number of elements until the first NULL element
Definition: libsheepy.c:50820
getAtSmallJsonSmallArray
internal smallJsont * getAtSmallJsonSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7198
cropElemSmallContainerSmallArray
internal smallContainert * cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4786
icIndexOfSmallJsonSmallArray
internal ssize_t icIndexOfSmallJsonSmallArray(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:10304
sortFSmallArray
internal smallArrayt * sortFSmallArray(smallArrayt *self, shCmpt compareFunction)
Definition: libsheepyCSmallArray.c:6426
injectDictSmallArrayG
smallArrayt * injectDictSmallArrayG(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:13652
popSmallIntSmallArray
internal smallIntt * popSmallIntSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2571
cleanUpSmallArraySmashG
void cleanUpSmallArraySmashG(smallArrayt **val)
Definition: libsheepyCSmallArray.c:1488
icBinarySearchSmallArrayG
ssize_t icBinarySearchSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:14245
icEqualSmallArraySmallJson
internal bool icEqualSmallArraySmallJson(smallArrayt *self, smallJsont *array)
Definition: libsheepyCSmallArray.c:6741
smallArrayFunctionst::duplicate
duplicateSmallArrayFt duplicate
Definition: libsheepyCSmallArray.h:1882
helpSmallArray
internal const char * helpSmallArray(smallArrayt UNUSED *self)
Definition: libsheepyCSmallArray.c:1638
getAtDictSmallArrayG
smallDictt * getAtDictSmallArrayG(smallArrayt *self, smallDictt *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13054
pushNFreeSmallBytesSmallArrayG
smallArrayt * pushNFreeSmallBytesSmallArrayG(smallArrayt *self, smallBytest *value)
Definition: libsheepyCSmallArray.c:12583
binarySearchSmallBoolSmallArray
internal ssize_t binarySearchSmallBoolSmallArray(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:9626
getAtUintSmallArray
internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7006
popSSmallArray
internal char * popSSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2409
binarySearchArraySmallArrayG
ssize_t binarySearchArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:14100
getAtSmallContainerSmallArray
internal smallContainert * getAtSmallContainerSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:7262
smallInt::f
smallIntFunctionst * f
Definition: libsheepyCSmallInt.h:227
popSmallJsonSmallArray
internal smallJsont * popSmallJsonSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2601
setAtVoidSmallArrayG
smallArrayt * setAtVoidSmallArrayG(smallArrayt *self, int64_t index, void *value)
Definition: libsheepyCSmallArray.c:13255
pushDoubleSmallArray
internal smallArrayt * pushDoubleSmallArray(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:1819
allocSArray
sArrayt * allocSArray(void)
allocate a small array
Definition: libsheepySmall.c:329
hasIntSmallArray
internal bool hasIntSmallArray(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:8556
dequeueSmallArray
internal baset * dequeueSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3163
sBoolt::value
bool value
Definition: libsheepySmall.h:76
pushNFreeO
#define pushNFreeO(self, value)
Definition: libsheepyObject.h:732
getAtSmallArrayG
baset * getAtSmallArrayG(smallArrayt *self, baset *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:12979
shiftSmallArray
internal smallArrayt * shiftSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:3899
injectArraySmallArrayG
smallArrayt * injectArraySmallArrayG(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13657
icBinarySearchArraycSmallArrayG
ssize_t icBinarySearchArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:14270
pushNFreeUndefinedSmallArrayG
smallArrayt * pushNFreeUndefinedSmallArrayG(smallArrayt *self, undefinedt *value)
Definition: libsheepyCSmallArray.c:12553
popSmallBoolSmallArray
internal smallBoolt * popSmallBoolSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2481
logSmallArrayG
void logSmallArrayG(smallArrayt *self)
Definition: libsheepyCSmallArray.c:14435
getAtSmallArray
baset * getAtSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6867
binarySearchBoolSmallArray
internal ssize_t binarySearchBoolSmallArray(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:9289
hasBoolSmallArrayG
bool hasBoolSmallArrayG(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:13890
pushManySSmallArray
internal smallArrayt * pushManySSmallArray(smallArrayt *self,...)
Definition: libsheepyCSmallArray.c:2211
prependNFreeSmallStringSmallArray
internal smallArrayt * prependNFreeSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:3145
setPAtArraySmallArray
internal smallArrayt * setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array)
Definition: libsheepyCSmallArray.c:8263
setPAtSmallJsonSmallArrayG
smallArrayt * setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json)
Definition: libsheepyCSmallArray.c:13379
binarySearchSmallBoolSmallArrayG
ssize_t binarySearchSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:14115
getAtSmallBytesSmallArrayG
smallBytest * getAtSmallBytesSmallArrayG(smallArrayt *self, smallBytest *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13069
pushSmallStringSmallArray
internal smallArrayt * pushSmallStringSmallArray(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:2031
freeManyS
#define freeManyS(...)
Definition: libsheepy.h:1867
popDoubleSmallArray
internal double popDoubleSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2349
injectNFreeArraycSmallArray
internal smallArrayt * injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject)
Definition: libsheepyCSmallArray.c:5952
popNumSmallArray
internal double popNumSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:2715
typeSmallStringsSmallArray
internal smallArrayt * typeSmallStringsSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:12248
prependSmallDoubleSmallArrayG
smallArrayt * prependSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:12788
zipCCharSmallArray
internal smallArrayt * zipCCharSmallArray(smallArrayt *self, smallArrayt *array1, const char **array2)
Definition: libsheepyCSmallArray.c:11808
iterStartSmallArray
internal baset * iterStartSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11107
u
undefinedt * u
Definition: libsheepyObjectTest.c:56
prependSmallStringSmallArrayG
smallArrayt * prependSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:12803
pushCArraycSmallArray
internal smallArrayt * pushCArraycSmallArray(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:1919
helpTextSmallArray
#define helpTextSmallArray
help text for this class It is public declaration so that child classes can add their help text easil...
Definition: libsheepyCSmallArray.h:35
sArrayTypes
sBytest * sArrayTypes(sArrayt *obj)
list first level of object types in array
Definition: libsheepySmall.c:1273
pushNFreeSmallContainerSmallArray
internal smallArrayt * pushNFreeSmallContainerSmallArray(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:2183
binarySearchSmallJsonSmallArrayG
ssize_t binarySearchSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:14135
pushSmallContainerSmallArrayG
smallArrayt * pushSmallContainerSmallArrayG(smallArrayt *self, smallContainert *container)
Definition: libsheepyCSmallArray.c:12542
getsoO
#define getsoO(self)
Definition: libsheepyObject.h:7506
joinSmallArray
internal smallStringt * joinSmallArray(smallArrayt *self, const char *delim)
Definition: libsheepyCSmallArray.c:11320
pushSmallBoolSmallArrayG
smallArrayt * pushSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *value)
Definition: libsheepyCSmallArray.c:12512
setAtNFreeDictSmallArray
internal smallArrayt * setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict)
Definition: libsheepyCSmallArray.c:8143
getAtNDupVoidSmallArrayG
void * getAtNDupVoidSmallArrayG(smallArrayt *self, void *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13190
indexOfSSmallArrayG
ssize_t indexOfSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:13995
createAllocateSmallArray
#define createAllocateSmallArray(obj)
Definition: libsheepyCSmallArray.h:1912
dequeueSmallJsonSmallArray
internal smallJsont * dequeueSmallJsonSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:3537
prependNFreeSmallDoubleSmallArrayG
smallArrayt * prependNFreeSmallDoubleSmallArrayG(smallArrayt *self, smallDoublet *value)
Definition: libsheepyCSmallArray.c:12854
prependDictSmallArray
internal smallArrayt * prependDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:2830
prependArraycSmallArrayG
smallArrayt * prependArraycSmallArrayG(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:12756
icEqualSmallArray
internal bool icEqualSmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:6639
iterStartLastSmallArray
internal baset * iterStartLastSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11139
hasCharSmallArray
internal bool hasCharSmallArray(smallArrayt *self, char c)
Definition: libsheepyCSmallArray.c:8578
setFromCSmallArrayG
smallArrayt * setFromCSmallArrayG(smallArrayt *self, const char **array)
Definition: libsheepyCSmallArray.c:12440
hasDoubleSmallArrayG
bool hasDoubleSmallArrayG(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:13895
areAllETypeSmallArray
internal bool areAllETypeSmallArray(smallArrayt *self, const char *type)
Definition: libsheepyCSmallArray.c:12339
finishO
#define finishO(obj)
free container only
Definition: libsheepyObject.h:373
isOSmallArray
#define isOSmallArray(obj)
test if obj type is smallArray
Definition: libsheepyObject.h:227
sArrayPopTiny
smallt * sArrayPopTiny(sArrayt *array)
pop object from array
Definition: libsheepySmall.c:1660
cropElemUint32SmallArray
internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4358
joinSmallArrayG
smallStringt * joinSmallArrayG(smallArrayt *self, const char *delim)
Definition: libsheepyCSmallArray.c:14315
getO
#define getO(self, key)
Definition: libsheepyObject.h:1772
popIntSmallArrayG
int64_t popIntSmallArrayG(smallArrayt *self, int64_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12635
shiftSmallJsonSmallArray
internal smallArrayt * shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:3904
isEUndefinedSmallArray
internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:12289
binarySearchArraySmallArray
internal ssize_t binarySearchArraySmallArray(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:9481
delSmallArrayG
smallArrayt * delSmallArrayG(smallArrayt *self, int64_t start, int64_t end)
Definition: libsheepyCSmallArray.c:13785
pushSmallArrayG
smallArrayt * pushSmallArrayG(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:12445
icBinarySearchSmallStringSmallArrayG
ssize_t icBinarySearchSmallStringSmallArrayG(smallArrayt *self, smallStringt *string)
Definition: libsheepyCSmallArray.c:14285
binarySearchSmallIntSmallArrayG
ssize_t binarySearchSmallIntSmallArrayG(smallArrayt *self, smallIntt *value)
Definition: libsheepyCSmallArray.c:14130
smashO
#define smashO(obj)
free object and keep data
Definition: libsheepyObject.h:357
injectUndefinedSmallArray
internal smallArrayt * injectUndefinedSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:5080
setAtBoolSmallArray
internal smallArrayt * setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value)
Definition: libsheepyCSmallArray.c:7686
smallArrayFunctionst::finish
finishSmallArrayFt finish
Definition: libsheepyCSmallArray.h:1884
icEqualSmallArrayCArray
bool icEqualSmallArrayCArray(smallArrayt *self, const char **p2)
Definition: libsheepyCSmallArray.c:6791
writeStreamSmallArray
internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp)
Definition: libsheepyCSmallArray.c:12150
smallDouble::f
smallDoubleFunctionst * f
Definition: libsheepyCSmallDouble.h:225
prependArraycSmallArray
internal smallArrayt * prependArraycSmallArray(smallArrayt *self, char **array)
Definition: libsheepyCSmallArray.c:2868
icIndexOfDictSmallArray
internal ssize_t icIndexOfDictSmallArray(smallArrayt *self, smallDictt *dict)
Definition: libsheepyCSmallArray.c:10180
indexOfArraySmallArrayG
ssize_t indexOfArraySmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:14010
getAtBoolPSmallArray
internal bool * getAtBoolPSmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:6922
setAtSmallArray
internal smallArrayt * setAtSmallArray(smallArrayt *self, int64_t index, baset *value)
Definition: libsheepyCSmallArray.c:7646
shiftSmallJsonSmallArrayG
smallArrayt * shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json)
Definition: libsheepyCSmallArray.c:13461
appendSmallArrayG
smallArrayt * appendSmallArrayG(smallArrayt *self, smallArrayt *array)
Definition: libsheepyCSmallArray.c:13419
binarySearchDoubleSmallArrayG
ssize_t binarySearchDoubleSmallArrayG(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:14075
popSmallBoolSmallArrayG
smallBoolt * popSmallBoolSmallArrayG(smallArrayt *self, smallBoolt *retType UNUSED)
Definition: libsheepyCSmallArray.c:12670
prependNFreeSmallArray
internal smallArrayt * prependNFreeSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:3036
sDuplicate
smallt * sDuplicate(smallt *o)
duplicate small object
Definition: libsheepySmall.c:485
hasIntSmallArrayG
bool hasIntSmallArrayG(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:13900
icHasSSmallArrayG
bool icHasSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:14160
setPAtNFreeSmallJsonSmallArray
internal smallArrayt * setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json)
Definition: libsheepyCSmallArray.c:8413
pushSSmallArrayG
smallArrayt * pushSSmallArrayG(smallArrayt *self, const char *string)
Definition: libsheepyCSmallArray.c:12470
zipCArraySmallJsonSmallArrayG
smallArrayt * zipCArraySmallJsonSmallArrayG(smallArrayt *self, const char **array1, smallJsont *array2)
Definition: libsheepyCSmallArray.c:14400
injectDoubleSmallArrayG
smallArrayt * injectDoubleSmallArrayG(smallArrayt *self, int64_t index, double value)
Definition: libsheepyCSmallArray.c:13632
hasSmallArray
internal bool hasSmallArray(smallArrayt *self, baset *value)
Definition: libsheepyCSmallArray.c:8508
injectSmallBoolSmallArrayG
smallArrayt * injectSmallBoolSmallArrayG(smallArrayt *self, int64_t index, smallBoolt *value)
Definition: libsheepyCSmallArray.c:13684
cleanUpSmallArrayFreeLocalG
void cleanUpSmallArrayFreeLocalG(smallArrayt *val)
Definition: libsheepyCSmallArray.c:1468
hasDoubleSmallArray
internal bool hasDoubleSmallArray(smallArrayt *self, double value)
Definition: libsheepyCSmallArray.c:8547
getAtNDupSmallArrayG
baset * getAtNDupSmallArrayG(smallArrayt *self, baset *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13105
binarySearchIntSmallArray
internal ssize_t binarySearchIntSmallArray(smallArrayt *self, int64_t value)
Definition: libsheepyCSmallArray.c:9358
readStreamSmallArray
internal smallArrayt * readStreamSmallArray(smallArrayt *self, FILE *fp)
Definition: libsheepyCSmallArray.c:12065
popUint32SmallArrayG
uint32_t popUint32SmallArrayG(smallArrayt *self, uint32_t retType UNUSED)
Definition: libsheepyCSmallArray.c:12650
isBlankSmallArray
internal bool isBlankSmallArray(smallArrayt *self)
Definition: libsheepyCSmallArray.c:11007
cropElemInt32SmallArray
internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index)
Definition: libsheepyCSmallArray.c:4274
indexOfSmallJsonSmallArrayG
ssize_t indexOfSmallJsonSmallArrayG(smallArrayt *self, smallJsont *string)
Definition: libsheepyCSmallArray.c:14045
logC
#define logC(...)
Definition: libsheepy.h:1059
duplicateO
#define duplicateO(obj)
create a copy of obj
Definition: libsheepyObject.h:351
getAtInt32PSmallArrayG
int32_t * getAtInt32PSmallArrayG(smallArrayt *self, int32_t *retType UNUSED, int64_t index)
Definition: libsheepyCSmallArray.c:13024
isOSmallString
#define isOSmallString(obj)
test if obj type is smallString
Definition: libsheepyObject.h:275
pushBoolSmallArray
internal smallArrayt * pushBoolSmallArray(smallArrayt *self, bool value)
Definition: libsheepyCSmallArray.c:1809
Generated on Thu Jul 13 2023 14:34:30 for libsheepy by   doxygen 1.8.13